@formicoidea/labre-core 0.40.0 → 0.41.0

package/dist/_pkgs/affine-block-surface/extensions/interchange.d.ts

@@ -97,21 +97,26 @@ export interface InterchangeNote {
     message: string;
     /**
      * The i18n key {@link message} is the English default of — set only when the
-     * remark is a FIXED sentence.
+     * remark is a FIXED sentence, one per SHAPE of sentence rather than one per
+     * exact string (a `{{name}}` hole is filled by {@link messageParams}, not by
+     * minting a new key for every value the file happens to carry).
      *
      * A reader is a pure function of text (`docs/adr/0012`, P3): it has no `std`,
      * so it cannot reach the host's catalogue and hands the key over instead, and
      * `reportInterchangeImport` resolves it when it draws the report. That is the
-     * whole of the seam here, and it deliberately covers only the remarks that
-     * say the same thing every time.
+     * whole of the seam here.
      *
-     * A remark that NAMES something out of the file — an element, an id, a count
-     * of lanes — carries no key and stays English. The seam has no interpolation
-     * and no pluralisation (both are the host's), so the alternative would be to
-     * invent a grammar for sentences with holes in them, which is exactly what
-     * the three interchange count labels already refuse to do.
+     * A remark that names something out of the file with no sentence shape worth
+     * sharing (a raw dump, a one-off diagnostic) carries no key and stays
+     * English — the seam still has no pluralisation, which is the host's.
      */
     messageKey?: string;
+    /**
+     * `{{name}}`-style values for {@link messageKey}'s placeholders — the file's
+     * own words (a unit, a tag name), never a sentence of their own. Ignored
+     * when {@link messageKey} is absent.
+     */
+    messageParams?: Record<string, string | number>;
 }
 /**
  * The five things worth saying about one item, and no sixth.
@@ -161,6 +166,33 @@ export interface InterchangeReport {
      */
     sourceVersion?: string;
 }
+/**
+ * A reader's own refusal — THROWN, not returned, because the report's three
+ * counts (`InterchangeReport`) cannot say "this is not a file I can read": a
+ * report of three zeroes would claim an empty document where there was none
+ * (see `importInterchangeFile`, "Failure is an exception, and it says which
+ * one", `interchange-import.ts`).
+ *
+ * Carries the reader's own English sentence as `Error.message`, so every
+ * existing `catch` site that only ever did `error.message` keeps reading
+ * exactly what it read before — plus the same optional key/params pair
+ * {@link InterchangeNote} carries, on the same seam: a reader has no `std`
+ * (`docs/adr/0012`, P3) and cannot translate its own refusal, so the catch
+ * site that DOES have one (`importInterchangeFile`) resolves it exactly as
+ * `remarkLine` resolves a note.
+ *
+ * Optional and additive: a reader that still throws a plain `Error` (or any
+ * other capability's failure) is caught exactly as before — this class only
+ * gives the catch site a SECOND thing to check, never a first requirement.
+ */
+export declare class InterchangeImportError extends Error {
+    readonly messageKey?: string;
+    readonly messageParams?: Record<string, string | number>;
+    constructor(message: string, options?: {
+        messageKey?: string;
+        messageParams?: Record<string, string | number>;
+    });
+}
 /** What the caller tells an exporter about the document it is producing. */
 export interface InterchangeExportContext {
     /**

package/dist/_pkgs/affine-block-surface/extensions/interchange.js

@@ -1,4 +1,31 @@
 import { createIdentifier } from '../../global/di/index.js';
+/**
+ * A reader's own refusal — THROWN, not returned, because the report's three
+ * counts (`InterchangeReport`) cannot say "this is not a file I can read": a
+ * report of three zeroes would claim an empty document where there was none
+ * (see `importInterchangeFile`, "Failure is an exception, and it says which
+ * one", `interchange-import.ts`).
+ *
+ * Carries the reader's own English sentence as `Error.message`, so every
+ * existing `catch` site that only ever did `error.message` keeps reading
+ * exactly what it read before — plus the same optional key/params pair
+ * {@link InterchangeNote} carries, on the same seam: a reader has no `std`
+ * (`docs/adr/0012`, P3) and cannot translate its own refusal, so the catch
+ * site that DOES have one (`importInterchangeFile`) resolves it exactly as
+ * `remarkLine` resolves a note.
+ *
+ * Optional and additive: a reader that still throws a plain `Error` (or any
+ * other capability's failure) is caught exactly as before — this class only
+ * gives the catch site a SECOND thing to check, never a first requirement.
+ */
+export class InterchangeImportError extends Error {
+    constructor(message, options) {
+        super(message);
+        this.name = 'InterchangeImportError';
+        this.messageKey = options?.messageKey;
+        this.messageParams = options?.messageParams;
+    }
+}
 /** The separator the triple is built from, and therefore reserved in its parts. */
 const ID_SEPARATOR = ':';
 /** The one way to spell a capability's id. */

package/dist/_pkgs/affine-block-surface/extensions/morph-toolbar.d.ts

@@ -1,5 +1,5 @@
 import { type ToolbarContext, type ToolbarModuleConfig } from '../../affine-shared/services/index.js';
-import type { FrameworkId } from '../../std/index.js';
+import type { BlockStdScope, FrameworkId } from '../../std/index.js';
 import type { GfxPrimitiveElementModel } from '../../std/gfx/index.js';
 import type { TemplateResult } from 'lit';
 /**
@@ -148,7 +148,7 @@ export interface MorphSpec<K extends string = string> {
      * still says what the SOURCE kind derived may be rewritten, and a line the
      * author typed over is theirs.
      */
-    afterMorph?(model: GfxPrimitiveElementModel, from: K, to: K): void;
+    afterMorph?(model: GfxPrimitiveElementModel, from: K, to: K, std?: BlockStdScope): void;
     /** The role a kind means — the `from` / `to` of the telemetry, ids only. */
     roleOf(kind: K): string;
     /**

package/dist/_pkgs/affine-block-surface/extensions/morph-toolbar.js

@@ -158,8 +158,11 @@ export function applyMorph(ctx, spec, kind) {
             entry.target.clearField(field);
         // Inside the loop and inside the one checkpoint above: whatever the rest of
         // a composite owes this morph — C4's type line — is part of the same single
-        // ctrl+z as the kind that made it necessary.
-        spec.afterMorph?.(entry.selected, entry.kind, kind);
+        // ctrl+z as the kind that made it necessary. `ctx.std` is handed through so
+        // a rewrite can tell an untouched TRANSLATED placeholder from real content
+        // (`c4MorphedTypeLine`, `wardleyMorphedLabel`) — with no host it behaves
+        // exactly as it always has, English only.
+        spec.afterMorph?.(entry.selected, entry.kind, kind, ctx.std);
     }
     // The one DIRECT emission in this module, and the arbitrated exception is the
     // same one the C4 legend button makes: there is no command behind this

package/dist/_pkgs/affine-block-surface/extensions/reading-widget.js

@@ -32,7 +32,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { buildOccurrencePatch, getUniverseRegistry, publishOccurrenceMaterialities, translateKey, } from '../../affine-shared/services/index.js';
+import { buildOccurrencePatch, getUniverseRegistry, publishOccurrenceMaterialities, translateKey, translateTagLabel, } from '../../affine-shared/services/index.js';
 import { getRegisteredCommands, runCommand, WidgetViewExtension, } from '../../std/index.js';
 import { resolvePivotBinding } from '../../std/gfx/index.js';
 import { effect } from '@preact/signals-core';
@@ -330,7 +330,8 @@ let ReadingProposalWidget = (() => {
             const def = getUniverseRegistry(this.std).tag(tagId);
             if (!def || def.values === 'open')
                 return valueId;
-            return def.values.find(value => value.id === valueId)?.label || valueId;
+            const value = def.values.find(value => value.id === valueId);
+            return (value && translateTagLabel(this.std, value)) || valueId;
         }
         _field(testid, label, body) {
             return html `<div class="reading-field" data-testid=${testid}>

package/dist/_pkgs/affine-block-surface/extensions/svg-sketch-translations.d.ts

@@ -0,0 +1,48 @@
+import type { ChromeWording } from '../../affine-shared/services/index.js';
+/**
+ * The SVG importer's own remarks (`svg-sketch.ts`) — one key per SENTENCE
+ * SHAPE, not per exact string: a `{{name}}` hole is filled by
+ * `InterchangeNote.messageParams` at report time
+ * (`interchange-import.ts`'s `remarkLine`), never split into two keys or
+ * baked into the key itself.
+ *
+ * The reader that raises these is a pure function of text (`docs/adr/0012`,
+ * P3): it has no `std`, so each note carries its key and (where it has one)
+ * its params, and `reportInterchangeImport` resolves both when it draws the
+ * report — see `InterchangeNote.messageKey` / `.messageParams`.
+ *
+ * NOT included: the three `throw new Error(...)` refusals `parseSvgRoot`
+ * raises for a malformed or empty file. Those are caught by
+ * `importInterchangeFile`'s single, format-agnostic `catch` — shared by
+ * every interchange reader (BPMN, mermaid, OWM, this one) — which shows
+ * `error.message` verbatim BY DESIGN ("shown as it is rather than replaced
+ * with a wording of our own that knows less"). Keying them would mean
+ * teaching that shared catch to resolve a per-reader key, a mechanism this
+ * lot does not own the other readers to touch — flagged in this lot's report
+ * instead of invented here.
+ */
+export declare const SVG_SKETCH_FONT_UNIT: ChromeWording;
+export declare const SVG_SKETCH_HIDDEN_DISPLAY: ChromeWording;
+export declare const SVG_SKETCH_HIDDEN_VISIBILITY: ChromeWording;
+export declare const SVG_SKETCH_OPACITY: ChromeWording;
+export declare const SVG_SKETCH_PAINT_SERVER: ChromeWording;
+export declare const SVG_SKETCH_CURRENT_COLOR: ChromeWording;
+export declare const SVG_SKETCH_TRANSFORM: ChromeWording;
+export declare const SVG_SKETCH_LONE_POINT: ChromeWording;
+export declare const SVG_SKETCH_CURVE: ChromeWording;
+export declare const SVG_SKETCH_EMPTY_BOX: ChromeWording;
+export declare const SVG_SKETCH_PERCENT_RADIUS: ChromeWording;
+export declare const SVG_SKETCH_FLAT_POLYGON: ChromeWording;
+export declare const SVG_SKETCH_EMPTY_TEXT: ChromeWording;
+export declare const SVG_SKETCH_SWITCH: ChromeWording;
+export declare const SVG_SKETCH_SKIPPED: ChromeWording;
+export declare const SVG_SKETCH_REMOVED: ChromeWording;
+export declare const SVG_SKETCH_REMOVED_ATTRIBUTE: ChromeWording;
+export declare const SVG_SKETCH_EMPTY: ChromeWording;
+/**
+ * Every wording declared above, in declaration order — joined into
+ * `PACKAGE_WORDINGS` (`packages/affine/all/src/translations.ts`) alongside
+ * `PROVENANCE_FALLBACK`/`SEVERITY_FALLBACK`/`EXEMPTION_FALLBACK`, this
+ * package's other manifest contributions.
+ */
+export declare const SVG_SKETCH_WORDINGS: readonly ChromeWording[];

package/dist/_pkgs/affine-block-surface/extensions/svg-sketch-translations.js

@@ -0,0 +1,120 @@
+/**
+ * The SVG importer's own remarks (`svg-sketch.ts`) — one key per SENTENCE
+ * SHAPE, not per exact string: a `{{name}}` hole is filled by
+ * `InterchangeNote.messageParams` at report time
+ * (`interchange-import.ts`'s `remarkLine`), never split into two keys or
+ * baked into the key itself.
+ *
+ * The reader that raises these is a pure function of text (`docs/adr/0012`,
+ * P3): it has no `std`, so each note carries its key and (where it has one)
+ * its params, and `reportInterchangeImport` resolves both when it draws the
+ * report — see `InterchangeNote.messageKey` / `.messageParams`.
+ *
+ * NOT included: the three `throw new Error(...)` refusals `parseSvgRoot`
+ * raises for a malformed or empty file. Those are caught by
+ * `importInterchangeFile`'s single, format-agnostic `catch` — shared by
+ * every interchange reader (BPMN, mermaid, OWM, this one) — which shows
+ * `error.message` verbatim BY DESIGN ("shown as it is rather than replaced
+ * with a wording of our own that knows less"). Keying them would mean
+ * teaching that shared catch to resolve a per-reader key, a mechanism this
+ * lot does not own the other readers to touch — flagged in this lot's report
+ * instead of invented here.
+ */
+export const SVG_SKETCH_FONT_UNIT = [
+    'com.labre.interchange.svg.font-unit',
+    'Font sizes in `{{unit}}` cannot be resolved without a page to measure against; those labels use the inherited size.',
+];
+export const SVG_SKETCH_HIDDEN_DISPLAY = [
+    'com.labre.interchange.svg.hidden-display',
+    'Parts of the file marked `display:none` were not imported — they draw nothing where the file came from either.',
+];
+export const SVG_SKETCH_HIDDEN_VISIBILITY = [
+    'com.labre.interchange.svg.hidden-visibility',
+    'Parts of the file marked `visibility:hidden` were not imported — they draw nothing where the file came from either.',
+];
+export const SVG_SKETCH_OPACITY = [
+    'com.labre.interchange.svg.opacity',
+    'Transparency is not carried: partly transparent shapes arrive at full strength.',
+];
+export const SVG_SKETCH_PAINT_SERVER = [
+    'com.labre.interchange.svg.paint-server',
+    'Gradients and patterns are not read; the shapes that used one are a flat neutral.',
+];
+export const SVG_SKETCH_CURRENT_COLOR = [
+    'com.labre.interchange.svg.current-color',
+    '`currentColor` has no page to inherit from here; the shapes that used it are a flat neutral.',
+];
+export const SVG_SKETCH_TRANSFORM = [
+    'com.labre.interchange.svg.transform',
+    '`{{kind}}` transforms are ignored (best effort): what carried one is placed as if it did not.',
+];
+export const SVG_SKETCH_LONE_POINT = [
+    'com.labre.interchange.svg.lone-point',
+    'A path that never moved anywhere draws nothing and was skipped.',
+];
+export const SVG_SKETCH_CURVE = [
+    'com.labre.interchange.svg.curve',
+    'Curves are approximated by their endpoints (best effort), so a curved path arrives as straight segments.',
+];
+export const SVG_SKETCH_EMPTY_BOX = [
+    'com.labre.interchange.svg.empty-box',
+    'Shapes with no width or height were skipped.',
+];
+export const SVG_SKETCH_PERCENT_RADIUS = [
+    'com.labre.interchange.svg.percent-radius',
+    'Corner radii given as a percentage were not read; those corners arrive square.',
+];
+export const SVG_SKETCH_FLAT_POLYGON = [
+    'com.labre.interchange.svg.flat-polygon',
+    'A polygon with fewer than three corners, or flat on one axis, arrives as its bounding rectangle.',
+];
+export const SVG_SKETCH_EMPTY_TEXT = [
+    'com.labre.interchange.svg.empty-text',
+    'Empty text elements were skipped.',
+];
+export const SVG_SKETCH_SWITCH = [
+    'com.labre.interchange.svg.switch',
+    'A `<switch>` offers alternative renderings; the first was imported and the others were not.',
+];
+export const SVG_SKETCH_SKIPPED = [
+    'com.labre.interchange.svg.skipped',
+    '`<{{name}}>` is not recognised and was skipped.',
+];
+export const SVG_SKETCH_REMOVED = [
+    'com.labre.interchange.svg.removed',
+    '`<{{name}}>` was removed while sanitizing the file — it is one of the constructs an SVG can carry code in — so nothing it drew was imported.',
+];
+export const SVG_SKETCH_REMOVED_ATTRIBUTE = [
+    'com.labre.interchange.svg.removed-attribute',
+    'Attributes outside the safe SVG drawing vocabulary — event handlers, script URLs, and anything else the sanitizer does not know — were removed before the file was read.',
+];
+export const SVG_SKETCH_EMPTY = [
+    'com.labre.interchange.svg.empty',
+    'No shape or text was recognised in this SVG, so nothing was drawn.',
+];
+/**
+ * Every wording declared above, in declaration order — joined into
+ * `PACKAGE_WORDINGS` (`packages/affine/all/src/translations.ts`) alongside
+ * `PROVENANCE_FALLBACK`/`SEVERITY_FALLBACK`/`EXEMPTION_FALLBACK`, this
+ * package's other manifest contributions.
+ */
+export const SVG_SKETCH_WORDINGS = [
+    SVG_SKETCH_FONT_UNIT,
+    SVG_SKETCH_HIDDEN_DISPLAY,
+    SVG_SKETCH_HIDDEN_VISIBILITY,
+    SVG_SKETCH_OPACITY,
+    SVG_SKETCH_PAINT_SERVER,
+    SVG_SKETCH_CURRENT_COLOR,
+    SVG_SKETCH_TRANSFORM,
+    SVG_SKETCH_LONE_POINT,
+    SVG_SKETCH_CURVE,
+    SVG_SKETCH_EMPTY_BOX,
+    SVG_SKETCH_PERCENT_RADIUS,
+    SVG_SKETCH_FLAT_POLYGON,
+    SVG_SKETCH_EMPTY_TEXT,
+    SVG_SKETCH_SWITCH,
+    SVG_SKETCH_SKIPPED,
+    SVG_SKETCH_REMOVED,
+    SVG_SKETCH_REMOVED_ATTRIBUTE,
+    SVG_SKETCH_EMPTY,
+];

package/dist/_pkgs/affine-block-surface/extensions/svg-sketch.js

@@ -1,5 +1,6 @@
 import { ShapeStyle, ShapeType, StrokeStyle, TextAlign, } from '../../affine-model/index.js';
 import DOMPurify from 'dompurify';
+import { SVG_SKETCH_CURRENT_COLOR, SVG_SKETCH_CURVE, SVG_SKETCH_EMPTY, SVG_SKETCH_EMPTY_BOX, SVG_SKETCH_EMPTY_TEXT, SVG_SKETCH_FLAT_POLYGON, SVG_SKETCH_FONT_UNIT, SVG_SKETCH_HIDDEN_DISPLAY, SVG_SKETCH_HIDDEN_VISIBILITY, SVG_SKETCH_LONE_POINT, SVG_SKETCH_OPACITY, SVG_SKETCH_PAINT_SERVER, SVG_SKETCH_PERCENT_RADIUS, SVG_SKETCH_REMOVED, SVG_SKETCH_REMOVED_ATTRIBUTE, SVG_SKETCH_SKIPPED, SVG_SKETCH_SWITCH, SVG_SKETCH_TRANSFORM, } from './svg-sketch-translations.js';
 /**
  * **SVG → a canvas sketch.** The platform's VISUAL-tier importer, shared by
  * every framework that declares it (`docs/adr/0012`, P2).
@@ -169,13 +170,25 @@ class Notebook {
         this.seen = new Set();
         this.notes = [];
     }
-    once(key, message, element) {
-        if (this.seen.has(key))
+    /**
+     * @param dedupKey De-duplication identity — a note fires once per distinct
+     *   value (`font-unit:px`, `font-unit:pt`…), independent of the i18n key
+     *   below, which stays the same across all of them.
+     * @param message The English sentence, already filled in with the file's
+     *   own words — shown as is with no host catalogue registered.
+     * @param wording The key/fallback pair for this sentence's SHAPE
+     *   (`svg-sketch-translations.ts`), and the params that fill its
+     *   `{{name}}` holes when it has any.
+     */
+    once(dedupKey, message, wording, params, element) {
+        if (this.seen.has(dedupKey))
             return;
-        this.seen.add(key);
+        this.seen.add(dedupKey);
         this.notes.push({
             kind: 'warning',
             message,
+            messageKey: wording[0],
+            ...(params ? { messageParams: params } : {}),
             ...(element ? { element } : {}),
         });
     }
@@ -226,7 +239,7 @@ function fontSizeOf(raw, inherited, notes) {
         return (value * 4) / 3;
     if (unit === 'em')
         return value * inherited;
-    notes.once(`font-unit:${unit}`, `Font sizes in \`${unit}\` cannot be resolved without a page to measure against; those labels use the inherited size.`);
+    notes.once(`font-unit:${unit}`, `Font sizes in \`${unit}\` cannot be resolved without a page to measure against; those labels use the inherited size.`, SVG_SKETCH_FONT_UNIT, { unit });
     return undefined;
 }
 /**
@@ -279,13 +292,13 @@ function isHidden(element, notes) {
     const style = styleMap(element);
     const display = style.get('display') ?? element.getAttribute('display');
     if (display?.trim() === 'none') {
-        notes.once('hidden:display', 'Parts of the file marked `display:none` were not imported — they draw nothing where the file came from either.');
+        notes.once('hidden:display', 'Parts of the file marked `display:none` were not imported — they draw nothing where the file came from either.', SVG_SKETCH_HIDDEN_DISPLAY);
         return true;
     }
     const visibility = style.get('visibility') ?? element.getAttribute('visibility');
     const hidden = visibility?.trim();
     if (hidden === 'hidden' || hidden === 'collapse') {
-        notes.once('hidden:visibility', 'Parts of the file marked `visibility:hidden` were not imported — they draw nothing where the file came from either.');
+        notes.once('hidden:visibility', 'Parts of the file marked `visibility:hidden` were not imported — they draw nothing where the file came from either.', SVG_SKETCH_HIDDEN_VISIBILITY);
         return true;
     }
     return false;
@@ -306,7 +319,7 @@ function noteOpacity(element, notes) {
             continue;
         const value = Number.parseFloat(raw);
         if (Number.isFinite(value) && value < 1) {
-            notes.once('opacity', 'Transparency is not carried: partly transparent shapes arrive at full strength.');
+            notes.once('opacity', 'Transparency is not carried: partly transparent shapes arrive at full strength.', SVG_SKETCH_OPACITY);
             return;
         }
     }
@@ -340,11 +353,11 @@ function colorOf(raw, fallback, notes) {
     if (!value || value === 'none' || value === 'transparent')
         return undefined;
     if (value.startsWith('url(')) {
-        notes.once('paint-server', 'Gradients and patterns are not read; the shapes that used one are a flat neutral.');
+        notes.once('paint-server', 'Gradients and patterns are not read; the shapes that used one are a flat neutral.', SVG_SKETCH_PAINT_SERVER);
         return fallback;
     }
     if (value === 'currentColor') {
-        notes.once('current-color', '`currentColor` has no page to inherit from here; the shapes that used it are a flat neutral.');
+        notes.once('current-color', '`currentColor` has no page to inherit from here; the shapes that used it are a flat neutral.', SVG_SKETCH_CURRENT_COLOR);
         return fallback;
     }
     return value;
@@ -412,7 +425,7 @@ function translated(element, frame, notes) {
             ty += values[1] ?? 0;
             continue;
         }
-        notes.once(`transform:${kind}`, `\`${kind}\` transforms are ignored (best effort): what carried one is placed as if it did not.`);
+        notes.once(`transform:${kind}`, `\`${kind}\` transforms are ignored (best effort): what carried one is placed as if it did not.`, SVG_SKETCH_TRANSFORM, { kind });
     }
     // A translate is expressed in the PARENT's user units, so it is scaled by the
     // frame it was written in and never by the one it creates.
@@ -463,7 +476,7 @@ function samplePath(d, notes) {
         if (current.length >= 2)
             subpaths.push(current);
         else if (current.length === 1) {
-            notes.once('lone-point', 'A path that never moved anywhere draws nothing and was skipped.');
+            notes.once('lone-point', 'A path that never moved anywhere draws nothing and was skipped.', SVG_SKETCH_LONE_POINT);
         }
         current = [];
     };
@@ -480,7 +493,7 @@ function samplePath(d, notes) {
             continue;
         }
         if (CURVE_COMMANDS.has(kind)) {
-            notes.once('curve', 'Curves are approximated by their endpoints (best effort), so a curved path arrives as straight segments.');
+            notes.once('curve', 'Curves are approximated by their endpoints (best effort), so a curved path arrives as straight segments.', SVG_SKETCH_CURVE);
         }
         // One command letter may carry SEVERAL argument groups (`L 1 2 3 4`), and
         // a repeated `M` group is an implicit lineto — the spec's own rule, and the
@@ -532,7 +545,7 @@ function readRect(element, frame, paint, sketch) {
     const w = num(element, 'width');
     const h = num(element, 'height');
     if (w <= 0 || h <= 0) {
-        sketch.notes.once('empty-box', EMPTY_BOX_NOTE);
+        sketch.notes.once('empty-box', EMPTY_BOX_NOTE, SVG_SKETCH_EMPTY_BOX);
         return;
     }
     // `rx` is an absolute corner radius in user units, and the shape model reads
@@ -545,7 +558,7 @@ function readRect(element, frame, paint, sketch) {
     const rawRadius = element.getAttribute('rx') ?? element.getAttribute('ry');
     let radius = 0;
     if (rawRadius?.includes('%')) {
-        sketch.notes.once('percent-radius', 'Corner radii given as a percentage were not read; those corners arrive square.');
+        sketch.notes.once('percent-radius', 'Corner radii given as a percentage were not read; those corners arrive square.', SVG_SKETCH_PERCENT_RADIUS);
     }
     else {
         const scaled = len(frame, num(element, 'rx', num(element, 'ry')));
@@ -564,7 +577,7 @@ function readEllipse(element, frame, paint, sketch) {
     const rx = circle ? r : num(element, 'rx');
     const ry = circle ? r : num(element, 'ry');
     if (rx <= 0 || ry <= 0) {
-        sketch.notes.once('empty-box', EMPTY_BOX_NOTE);
+        sketch.notes.once('empty-box', EMPTY_BOX_NOTE, SVG_SKETCH_EMPTY_BOX);
         return;
     }
     const cx = num(element, 'cx');
@@ -600,10 +613,10 @@ function readPolygon(element, frame, paint, sketch) {
     const h = Math.max(...ys) - minY;
     if (points.length < 3 || w <= 0 || h <= 0) {
         if (points.length === 0 || w < 0 || h < 0) {
-            sketch.notes.once('empty-box', EMPTY_BOX_NOTE);
+            sketch.notes.once('empty-box', EMPTY_BOX_NOTE, SVG_SKETCH_EMPTY_BOX);
             return;
         }
-        sketch.notes.once('flat-polygon', 'A polygon with fewer than three corners, or flat on one axis, arrives as its bounding rectangle.');
+        sketch.notes.once('flat-polygon', 'A polygon with fewer than three corners, or flat on one axis, arrives as its bounding rectangle.', SVG_SKETCH_FLAT_POLYGON);
         sketch.elements.push({
             ...shapeProps(paint, frame, sketch),
             shapeType: ShapeType.Rect,
@@ -710,7 +723,7 @@ function readText(element, frame, paint, sketch) {
         }
     }
     if (lines.length === 0) {
-        sketch.notes.once('empty-text', 'Empty text elements were skipped.');
+        sketch.notes.once('empty-text', 'Empty text elements were skipped.', SVG_SKETCH_EMPTY_TEXT);
         return;
     }
     const fontSize = len(frame, paint.fontSize ?? DEFAULT_FONT_SIZE);
@@ -780,7 +793,7 @@ function visit(element, frame, inherited, sketch) {
         // of a label on top of itself.
         const [first, ...rest] = childElements(element).filter(child => !NON_RENDERING.has(nameOf(child)));
         if (rest.length > 0) {
-            sketch.notes.once('switch', 'A `<switch>` offers alternative renderings; the first was imported and the others were not.');
+            sketch.notes.once('switch', 'A `<switch>` offers alternative renderings; the first was imported and the others were not.', SVG_SKETCH_SWITCH);
         }
         if (first)
             visit(first, here, paint, sketch);
@@ -834,7 +847,7 @@ function emit(element, name, frame, paint, sketch) {
             // and whatever SVG grows next. A drawing built out of symbol instances
             // arrives nearly empty, and this is the line that tells its author why
             // instead of leaving them to guess.
-            sketch.notes.once(`skipped:${name}`, `\`<${name}>\` is not recognised and was skipped.`, name);
+            sketch.notes.once(`skipped:${name}`, `\`<${name}>\` is not recognised and was skipped.`, SVG_SKETCH_SKIPPED, { name }, name);
     }
 }
 /* ── The capability's function ────────────────────────────────────────── */
@@ -896,14 +909,14 @@ function parseSvgRoot(source, notes) {
             // plumbing.
             if (PARSER_SCAFFOLDING.has(name.toLowerCase()))
                 continue;
-            notes.once(`removed:${name.toLowerCase()}`, `\`<${name}>\` was removed while sanitizing the file — it is one of the constructs an SVG can carry code in — so nothing it drew was imported.`, name);
+            notes.once(`removed:${name.toLowerCase()}`, `\`<${name}>\` was removed while sanitizing the file — it is one of the constructs an SVG can carry code in — so nothing it drew was imported.`, SVG_SKETCH_REMOVED, { name }, name);
         }
         else if (removed.attribute) {
             // Worded for what this actually is, which is broader than "unsafe": the
             // sanitizer's allow-list drops an event handler AND a `requiredFeatures`,
             // and calling the second one dangerous would be this reader accusing a
             // perfectly ordinary file of something.
-            notes.once('removed-attribute', 'Attributes outside the safe SVG drawing vocabulary — event handlers, script URLs, and anything else the sanitizer does not know — were removed before the file was read.');
+            notes.once('removed-attribute', 'Attributes outside the safe SVG drawing vocabulary — event handlers, script URLs, and anything else the sanitizer does not know — were removed before the file was read.', SVG_SKETCH_REMOVED_ATTRIBUTE);
         }
     }
     // No cast: `RETURN_DOM: true` in the literal selects DOMPurify's typed
@@ -937,7 +950,7 @@ export function parseSvgSketch(source, context = {}) {
     // every shape under it inherits — and it establishes the outermost viewport.
     walk(root, viewportFrame(root, IDENTITY), paintOf(root, INITIAL_PAINT, sketch.notes), sketch);
     if (sketch.elements.length === 0) {
-        sketch.notes.once('empty', 'No shape or text was recognised in this SVG, so nothing was drawn.');
+        sketch.notes.once('empty', 'No shape or text was recognised in this SVG, so nothing was drawn.', SVG_SKETCH_EMPTY);
     }
     return {
         elements: sketch.elements,

package/dist/_pkgs/affine-block-surface/extensions/tags-toolbar.js

@@ -1,5 +1,5 @@
 import { EditorChevronDown } from '../../affine-components/toolbar/index.js';
-import { getUniverseRegistry, translateKey, } from '../../affine-shared/services/index.js';
+import { getUniverseRegistry, translateKey, translateTagLabel, } from '../../affine-shared/services/index.js';
 import { getRegisteredCommands, runCommand } from '../../std/index.js';
 import { elementTagValues, GfxGroupLikeElementModel, GfxPrimitiveElementModel, } from '../../std/gfx/index.js';
 import { html, nothing } from 'lit';
@@ -190,10 +190,10 @@ function runTagSet(ctx, target, tag, values) {
 /** One titled block of the dropdown — one tag. */
 function renderSection(ctx, target, def) {
     const selected = elementTagValues(target.element, def.id);
-    const label = def.label || def.id;
+    const label = translateTagLabel(ctx.std, def) || def.id;
     const options = offeredValues(def, selected).map(value => {
         const on = selected.includes(value.id);
-        const valueLabel = value.label || value.id;
+        const valueLabel = translateTagLabel(ctx.std, value) || value.id;
         // `data-toggle` beside `data-option`: the row draws like a native option,
         // but clicking the value in FORCE is how it is un-picked (`toggleValue`),
         // whatever the tag's cardinality. Without it the selected row inherits
@@ -240,14 +240,14 @@ function triggerLabel(ctx, target) {
         const selected = elementTagValues(target.element, def.id);
         return offeredValues(def, selected)
             .filter(value => selected.includes(value.id))
-            .map(value => value.label || value.id);
+            .map(value => translateTagLabel(ctx.std, value) || value.id);
     });
     return chosen.length
         ? chosen.join(', ')
         : // One applicable tag names itself ("Nature"); several fall back to the
             // neutral word, since no single tag name is the truth about the element.
             target.tags.length === 1
-                ? target.tags[0].label || target.tags[0].id
+                ? translateTagLabel(ctx.std, target.tags[0]) || target.tags[0].id
                 : translateKey(ctx.std, 'com.labre.tags.toolbar.label', 'Qualify');
 }
 /**

package/dist/_pkgs/affine-block-surface-ref/components/placeholder.d.ts

@@ -1,5 +1,5 @@
 import { ColorScheme } from '../../affine-model/index.js';
-import { ShadowlessElement } from '../../std/index.js';
+import { type BlockStdScope, ShadowlessElement } from '../../std/index.js';
 import { type GfxModel } from '../../std/gfx/index.js';
 import { nothing } from 'lit';
 declare const SurfaceRefPlaceHolder_base: typeof ShadowlessElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
@@ -9,6 +9,7 @@ export declare class SurfaceRefPlaceHolder extends SurfaceRefPlaceHolder_base {
     accessor refFlavour: string;
     accessor inEdgeless: boolean;
     accessor theme: ColorScheme;
+    accessor std: BlockStdScope;
     render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 declare global {