@formicoidea/labre-core 0.40.0 → 0.42.0

package/dist/_pkgs/std/gfx/model/surface/surface-model.js

@@ -189,6 +189,21 @@ export class SurfaceBlockModel extends BlockModel {
         'rotate',
         'hidden',
     ]); }
+    /**
+     * The elements this surface built from a Y.Map that was missing a key it
+     * declares — today only `xywh`, the bound without which the element paints
+     * nothing (see {@link _createElementFromYMap}).
+     *
+     * **State, not just a signal.** The element models are built when the block
+     * model is created, before any view or `LifeCycleWatcher` is mounted, so a
+     * subscriber to {@link elementDamaged} would always be too late for the
+     * elements the document opened with. Whoever wants to count damaged
+     * documents reads this map at mount, then subscribes for what sync brings
+     * afterwards.
+     */
+    get damagedElements() {
+        return this._damagedElements;
+    }
     get elementModels() {
         const models = [];
         this._elementModels.forEach(model => models.push(model.model));
@@ -219,10 +234,17 @@ export class SurfaceBlockModel extends BlockModel {
         this.elementAdded = new Subject();
         this.elementRemoved = new Subject();
         this.elementUpdated = new Subject();
+        /**
+         * An element was found damaged — see {@link damagedElements}. Pushed at the
+         * same moment the console line is written, so a subscriber that arrives
+         * later reads the map instead and misses nothing.
+         */
+        this.elementDamaged = new Subject();
         this.localElementAdded = new Subject();
         this.localElementDeleted = new Subject();
         this.localElementUpdated = new Subject();
         this._isEmpty$ = signal(false);
+        this._damagedElements = new Map();
         const subscription = this.created.subscribe(() => {
             this._init();
             subscription.unsubscribe();
@@ -338,6 +360,27 @@ export class SurfaceBlockModel extends BlockModel {
         delete Ctor['_decoratorState'];
         state.creating = false;
         state.skipField = false;
+        // A document whose Yjs state still has pending structs can carry an element
+        // whose `xywh` key never arrived. The element reads its `[0,0,0,0]` fallback
+        // and paints nothing instead of a phantom shape at the origin — say so ONCE
+        // here, where every element model is built from its Y.Map, and never again
+        // from a getter that runs several times per frame. Group-like elements are
+        // excluded for free: their `xywh` is a derived getter, not a declared field.
+        //
+        // Only a map that is IN the document is asked: a brand-new element is built
+        // from a detached Y.Map whose keys still sit in Yjs' preliminary content,
+        // where `has()` sees nothing (and warns about the premature read).
+        if (yMap.doc &&
+            getFieldPropsSet(elementModel).has('xywh') &&
+            !yMap.has('xywh')) {
+            // The console line stays: std runs standalone, with no telemetry bus of
+            // its own. The state and the subject below are what makes the same fact
+            // COUNTABLE by a host that has one.
+            console.warn(`[labre] surface element ${type} ${id} has no xywh: rendering it with ` +
+                `a zero-size bound; the document is damaged`);
+            this._damagedElements.set(id, { type, reason: 'missing-xywh' });
+            this.elementDamaged.next({ id, type, reason: 'missing-xywh' });
+        }
         const unmount = () => {
             mounted = false;
             elementModel.onDestroyed();
@@ -458,6 +501,7 @@ export class SurfaceBlockModel extends BlockModel {
                             const { model, unmount } = this._elementModels.get(id);
                             removeFromType(model.type, model);
                             this._elementModels.delete(id);
+                            this._damagedElements.delete(id);
                             deletedElements.push({ model, unmount });
                         }
                         break;
@@ -510,10 +554,11 @@ export class SurfaceBlockModel extends BlockModel {
                     if (isGfxGroupCompatibleModel(payload.model)) {
                         this._groupLikeModels.delete(payload.id);
                     }
-                    // Same rule as `_watchGroupRelationChange`: the author already
+                    // Same rule as `_watchGroupRelationChange`: cascade only on a local
+                    // edit, and only if the store is writeable. The author already
                     // dropped the block from its group, and `removeChild` is a raw
                     // `transact` — on a readonly viewer it would be a silent write.
-                    if (payload.isLocal) {
+                    if (payload.isLocal && !this.store.readonly) {
                         const group = this.getGroup(payload.id);
                         if (group) {
                             // oxlint-disable-next-line unicorn/prefer-dom-node-remove
@@ -572,7 +617,10 @@ export class SurfaceBlockModel extends BlockModel {
             // the same sync. Reacting to a REMOTE update with a local write is
             // redundant on a writeable peer and, on a readonly viewer, the
             // production exception `Cannot remove element in readonly mode`.
-            if (!local)
+            // A readonly peer never cascades either, whatever the provenance of
+            // the update: it may not write at all, and a lingering empty group is
+            // harmless — the author's own cascade arrives through sync.
+            if (!local || this.store.readonly)
                 return;
             const element = this.getElementById(id);
             if (isGroup(element) &&
@@ -640,6 +688,37 @@ export class SurfaceBlockModel extends BlockModel {
         });
         return id;
     }
+    /**
+     * Build the element `addElement` would build from `props`, and stop there:
+     * FOR PREVIEWS ONLY — the model never enters the document.
+     *
+     * The props take the insertion path up to the moment the Y.Map would be
+     * attached — the `beforeAdd` middlewares (the author's last-used style), the
+     * class's `propsToY` (a string `text` becomes a `Y.Text`), the declared-prop
+     * routing — so a preview paints exactly what the placed element will. What
+     * `addElement` does next is skipped: the model is not registered (no
+     * `getElementById`, no `elementModels`), is never mounted (no observers, no
+     * `onChange`), emits no `elementAdded`, and opens no transaction.
+     *
+     * Its Y.Map is then parked in a throwaway `Y.Doc` of its own, because the
+     * values of a map that belongs to no document cannot be read (a `Y.Text`
+     * reads empty) — and a renderer needs to read them. That doc is not the
+     * store's; a renderer that WROTE to the model would still reach the store's
+     * `transact`, which is why a preview must only ever be rendered.
+     *
+     * `props.id` is required and is the caller's: nothing checks it against the
+     * document, since nothing is added to it.
+     */
+    createDetachedElement(props) {
+        const middlewareCtx = {
+            type: 'beforeAdd',
+            payload: { type: props.type, props: { ...props } },
+        };
+        this._middlewares.forEach(mid => mid(middlewareCtx));
+        const { model } = this._createElementFromProps({ ...middlewareCtx.payload.props, id: props.id }, { onChange: () => { } });
+        new Y.Doc().getMap('preview').set(props.id, model.yMap);
+        return model;
+    }
     addLocalElement(elem) {
         this.localElements.add(elem);
         this.localElementAdded.next(elem);
@@ -682,8 +761,10 @@ export class SurfaceBlockModel extends BlockModel {
         this.elementAdded.complete();
         this.elementRemoved.complete();
         this.elementUpdated.complete();
+        this.elementDamaged.complete();
         this._elementModels.forEach(({ unmount }) => unmount());
         this._elementModels.clear();
+        this._damagedElements.clear();
     }
     getElementById(id) {
         return this._elementModels.get(id)?.model ?? null;

package/dist/_pkgs/std/gfx/view/view.d.ts

@@ -1,6 +1,6 @@
 import { type Container } from '../../../global/di/index.js';
 import { DisposableGroup } from '../../../global/disposable/index.js';
-import { type Bound, type IVec } from '../../../global/gfx/index.js';
+import { Bound, type IVec } from '../../../global/gfx/index.js';
 import type { Extension } from '../../../store/index.js';
 import type { PointerEventState } from '../../event/index.js';
 import type { EditorHost } from '../../view/index.js';
@@ -57,7 +57,16 @@ export declare class GfxElementModelView<T extends GfxLocalElementModel | GfxPri
     onDragStart(_: DragStartContext): void;
     onDragEnd(_: DragEndContext): void;
     onDragMove({ dx, dy, currentBound }: DragMoveContext): void;
-    onBoxSelected(_: BoxSelectionContext): boolean | void;
+    /**
+     * Whether a box (marquee) selection takes this element. `false` keeps it
+     * out; anything else keeps the default (any overlap selects).
+     *
+     * A model may carry its own answer as `boxSelectable(box)` — a framework
+     * background does, to join a marquee only when the marquee contains it —
+     * and the default view defers to it, so every view of such a model gets the
+     * rule without restating it.
+     */
+    onBoxSelected(context: BoxSelectionContext): boolean | void;
     /**
      * Called when the view is destroyed.
      * Override this method requires calling `super.onDestroyed()`.

package/dist/_pkgs/std/gfx/view/view.js

@@ -1,7 +1,7 @@
 import { createIdentifier } from '../../../global/di/index.js';
 import { DisposableGroup } from '../../../global/disposable/index.js';
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
-import {} from '../../../global/gfx/index.js';
+import { Bound } from '../../../global/gfx/index.js';
 import { GfxPrimitiveElementModel } from '../model/surface/element-model.js';
 export const GfxElementModelViewExtIdentifier = createIdentifier('GfxElementModelView');
 export class GfxElementModelView {
@@ -104,7 +104,21 @@ export class GfxElementModelView {
     onDragMove({ dx, dy, currentBound }) {
         this.model.xywh = currentBound.moveDelta(dx, dy).serialize();
     }
-    onBoxSelected(_) { }
+    /**
+     * Whether a box (marquee) selection takes this element. `false` keeps it
+     * out; anything else keeps the default (any overlap selects).
+     *
+     * A model may carry its own answer as `boxSelectable(box)` — a framework
+     * background does, to join a marquee only when the marquee contains it —
+     * and the default view defers to it, so every view of such a model gets the
+     * rule without restating it.
+     */
+    onBoxSelected(context) {
+        const model = this.model;
+        if (typeof model.boxSelectable === 'function') {
+            return model.boxSelectable(Bound.from(context.box));
+        }
+    }
     /**
      * Called when the view is destroyed.
      * Override this method requires calling `super.onDestroyed()`.

package/dist/_pkgs/std/translations.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This package's own wordings, joined into `PACKAGE_WORDINGS` in
+ * `@labre/affine/translations` — see that file and
+ * `packages/affine/shared/src/services/translation-service/README.md`.
+ *
+ * A plain local tuple type, not `ChromeWording`
+ * (`@labre/affine-shared/services`): `@labre/std` must never import
+ * `@labre/affine-shared` (the dependency runs the other way — see
+ * `view/element/block-component.ts`'s own doc comment), so this package
+ * cannot reuse that type any more than it can reuse `translateKey` itself.
+ */
+type Wording = readonly [key: string, fallback: string];
+/**
+ * `BlockComponent.renderVersionMismatch`'s four wordings
+ * (`view/element/block-component.ts`) — the "Block Version Mismatched" card
+ * shown when a document carries a block flavour newer or older than this
+ * editor knows how to render.
+ */
+export declare const STD_VERSION_MISMATCH_TITLE: Wording;
+export declare const STD_VERSION_MISMATCH_BODY: Wording;
+export declare const STD_VERSION_MISMATCH_EDITOR_VERSION: Wording;
+export declare const STD_VERSION_MISMATCH_DATA_VERSION: Wording;
+export declare const STD_WORDINGS: readonly Wording[];
+export {};

package/dist/_pkgs/std/translations.js

@@ -0,0 +1,28 @@
+/**
+ * `BlockComponent.renderVersionMismatch`'s four wordings
+ * (`view/element/block-component.ts`) — the "Block Version Mismatched" card
+ * shown when a document carries a block flavour newer or older than this
+ * editor knows how to render.
+ */
+export const STD_VERSION_MISMATCH_TITLE = [
+    'com.labre.std.version-mismatch.title',
+    'Block Version Mismatched',
+];
+export const STD_VERSION_MISMATCH_BODY = [
+    'com.labre.std.version-mismatch.body',
+    'We can not render this {{flavour}} block because the version is mismatched.',
+];
+export const STD_VERSION_MISMATCH_EDITOR_VERSION = [
+    'com.labre.std.version-mismatch.editor-version',
+    'Editor version: {{version}}',
+];
+export const STD_VERSION_MISMATCH_DATA_VERSION = [
+    'com.labre.std.version-mismatch.data-version',
+    'Data version: {{version}}',
+];
+export const STD_WORDINGS = [
+    STD_VERSION_MISMATCH_TITLE,
+    STD_VERSION_MISMATCH_BODY,
+    STD_VERSION_MISMATCH_EDITOR_VERSION,
+    STD_VERSION_MISMATCH_DATA_VERSION,
+];

package/dist/_pkgs/std/view/element/block-component.js

@@ -32,6 +32,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
+import { createIdentifier } from '../../../global/di/index.js';
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
 import { SignalWatcher, WithDisposable } from '../../../global/lit/index.js';
 import { Store } from '../../../store/index.js';
@@ -44,10 +45,25 @@ import { when } from 'lit/directives/when.js';
 import { html } from 'lit/static-html.js';
 import { BlockServiceIdentifier } from '../../identifier.js';
 import { BlockSelection } from '../../selection/index.js';
+import { STD_VERSION_MISMATCH_BODY, STD_VERSION_MISMATCH_DATA_VERSION, STD_VERSION_MISMATCH_EDITOR_VERSION, STD_VERSION_MISMATCH_TITLE, } from '../../translations.js';
 import { PropTypes, requiredProperties } from '../decorators/index.js';
 import { blockComponentSymbol, modelContext, serviceContext, } from './consts.js';
 import { stdContext, storeContext } from './lit-host.js';
 import { ShadowlessElement } from './shadowless-element.js';
+const LocalTranslationProvider = createIdentifier('AffineTranslationService');
+/** `translateKey`'s own contract, replicated (see {@link LocalTranslationService}). */
+function localTranslate(std, key, fallback) {
+    const resolved = std.getOptional(LocalTranslationProvider)?.t(key);
+    return resolved !== undefined && resolved !== '' ? resolved : fallback;
+}
+const [VERSION_MISMATCH_TITLE_KEY, VERSION_MISMATCH_TITLE_FALLBACK] = STD_VERSION_MISMATCH_TITLE;
+const [VERSION_MISMATCH_BODY_KEY, VERSION_MISMATCH_BODY_FALLBACK] = STD_VERSION_MISMATCH_BODY;
+const [VERSION_MISMATCH_EDITOR_VERSION_KEY, VERSION_MISMATCH_EDITOR_VERSION_FALLBACK,] = STD_VERSION_MISMATCH_EDITOR_VERSION;
+const [VERSION_MISMATCH_DATA_VERSION_KEY, VERSION_MISMATCH_DATA_VERSION_FALLBACK,] = STD_VERSION_MISMATCH_DATA_VERSION;
+/** `translateKey`'s own `{{name}}` interpolation, replicated (see above). */
+function fillPlaceholder(template, name, value) {
+    return template.replace(new RegExp(`\\{\\{\\s*${name}\\s*\\}\\}`), value);
+}
 let BlockComponent = (() => {
     var _a;
     let _classDecorators = [requiredProperties({
@@ -259,18 +275,19 @@ let BlockComponent = (() => {
          * @param actualVersion The version of the block's crdt data.
          */
         renderVersionMismatch(expectedVersion, actualVersion) {
+            const title = localTranslate(this.std, VERSION_MISMATCH_TITLE_KEY, VERSION_MISMATCH_TITLE_FALLBACK);
+            const body = fillPlaceholder(localTranslate(this.std, VERSION_MISMATCH_BODY_KEY, VERSION_MISMATCH_BODY_FALLBACK), 'flavour', this.model.flavour);
+            const editorVersion = fillPlaceholder(localTranslate(this.std, VERSION_MISMATCH_EDITOR_VERSION_KEY, VERSION_MISMATCH_EDITOR_VERSION_FALLBACK), 'version', String(expectedVersion));
+            const dataVersion = fillPlaceholder(localTranslate(this.std, VERSION_MISMATCH_DATA_VERSION_KEY, VERSION_MISMATCH_DATA_VERSION_FALLBACK), 'version', String(actualVersion));
             return html `
       <dl class="version-mismatch-warning" contenteditable="false">
         <dt>
-          <h4>Block Version Mismatched</h4>
+          <h4>${title}</h4>
         </dt>
         <dd>
-          <p>
-            We can not render this <var>${this.model.flavour}</var> block
-            because the version is mismatched.
-          </p>
-          <p>Editor version: <var>${expectedVersion}</var></p>
-          <p>Data version: <var>${actualVersion}</var></p>
+          <p>${body}</p>
+          <p>${editorVersion}</p>
+          <p>${dataVersion}</p>
         </dd>
       </dl>
     `;

package/dist/commands.d.ts

@@ -35,6 +35,12 @@ export declare function buildCommandRegistry(core: AnyCommandDescriptor[], group
  * stay reachable on a board whose framework tooling is switched off; it is
  * registered from the always-on connector view extension for the same reason.
  *
+ * `export.svg` joins them on the same terms (`docs/adr/0025`): a board is a
+ * `FrameworkBackgroundElementModel` whatever framework drew it, and the picture
+ * it hands back is the canvas renderer's output replayed into SVG — so the
+ * command belongs to no framework, and a framework toggled off must still be
+ * able to export the boards already on the canvas.
+ *
  * `auditCommands` is `'core'`-owned but NOT always-on: it rides the `ai-audit`
  * capability switch, which is a second axis (see `OPTIONAL_CAPABILITIES`). The
  * read side is filtered here, the registration side by `AuditViewExtension` in

package/dist/commands.js

@@ -1,5 +1,5 @@
 import { coreCommands, pivotCommands, readingCommands, tagCommands, } from './_pkgs/affine-block-root/index.js';
-import { auditCommands, mapQualityCommands } from './_pkgs/affine-block-surface/index.js';
+import { auditCommands, exportSvgCommands, mapQualityCommands, } from './_pkgs/affine-block-surface/index.js';
 import { edgeDirectionCommands } from './_pkgs/affine-gfx-connector/index.js';
 import { shapeCommands } from './_pkgs/affine-gfx-shape/index.js';
 import { toCommandManifestEntry, } from './_pkgs/std/index.js';
@@ -27,6 +27,12 @@ export function buildCommandRegistry(core, groups, flags) {
  * stay reachable on a board whose framework tooling is switched off; it is
  * registered from the always-on connector view extension for the same reason.
  *
+ * `export.svg` joins them on the same terms (`docs/adr/0025`): a board is a
+ * `FrameworkBackgroundElementModel` whatever framework drew it, and the picture
+ * it hands back is the canvas renderer's output replayed into SVG — so the
+ * command belongs to no framework, and a framework toggled off must still be
+ * able to export the boards already on the canvas.
+ *
  * `auditCommands` is `'core'`-owned but NOT always-on: it rides the `ai-audit`
  * capability switch, which is a second axis (see `OPTIONAL_CAPABILITIES`). The
  * read side is filtered here, the registration side by `AuditViewExtension` in
@@ -46,6 +52,7 @@ export function getCommands(flags) {
         ...readingCommands,
         ...shapeCommands,
         ...mapQualityCommands,
+        ...exportSvgCommands,
         ...edgeDirectionCommands,
         ...(isCapabilityEnabled(flags, 'ai-audit') ? auditCommands : []),
     ], FRAMEWORK_COMMAND_GROUPS, flags);

package/dist/frameworks.d.ts

@@ -10,6 +10,15 @@ import type { OptionalBlock } from './flags.js';
  * read it (through a type-strip transform) instead of hand-maintaining its own
  * `FRAMEWORKS` array. Keep it that way. See `docs/adr/0008` § Packaging.
  *
+ * `iconKey` names the senior button's 56×56 glyph, registered in the framework's
+ * OWN command-icon table under `<segment>.toolbar` and therefore resolvable
+ * through `getCommandIcon`. The button still imports the glyph directly; the
+ * registry entry is what a host — or the catalogue — can resolve without it.
+ * Unlike the 24×24 command glyphs, it is `width="100%"` and fills whatever
+ * box it is put in.
+ * `__tests__/commands/registry.unit.spec.ts` ("every framework declares its own
+ * senior icon key") pins it non-empty, unique and registered.
+ *
  * `telemetryKey` and `telemetrySegment` hold the HISTORICAL PostHog values.
  * They are the reason the identity unification is code-side only and existing
  * dashboards keep working untouched — never "tidy" them.

package/dist/frameworks.js

@@ -162,6 +162,25 @@ export const FRAMEWORK_DESCRIPTORS = [
         ],
         shortcuts: true,
     },
+    {
+        id: 'uml',
+        labelKey: 'com.labre.framework.uml',
+        labelFallback: 'UML',
+        iconKey: 'uml.toolbar',
+        telemetryKey: 'uml',
+        telemetrySegment: 'uml toolbox',
+        bundle: 'framework-uml',
+        info: 'umlFramework',
+        pkg: '@labre/affine-gfx-uml',
+        dir: 'affine/gfx/uml',
+        extensions: [
+            // always-on: placed diagrams, subjects and nodes must paint with the
+            // button off, and their role vocabulary must stay readable
+            { viewExtension: 'UmlRenderViewExtension' },
+            { flag: 'uml', viewExtension: 'UmlViewExtension' },
+        ],
+        shortcuts: true,
+    },
 ];
 /**
  * Bundles that are NOT frameworks: no senior button, no commands, no identity

package/dist/translations.js

@@ -1,8 +1,59 @@
-import { EXEMPTION_FALLBACK, PROVENANCE_FALLBACK, SEVERITY_FALLBACK, } from './_pkgs/affine-block-surface/index.js';
-import { CHROME_WORDINGS } from './_pkgs/affine-shared/services/index.js';
+import { ATTACHMENT_WORDINGS } from './_pkgs/affine-block-attachment/translations.js';
+import { BOOKMARK_WORDINGS } from './_pkgs/affine-block-bookmark/translations.js';
+import { EMBED_WORDINGS } from './_pkgs/affine-block-embed/translations.js';
+import { EMBED_DOC_WORDINGS } from './_pkgs/affine-block-embed-doc/translations.js';
+import { FRAME_CHROME_WORDINGS, FRAME_WORDINGS, } from './_pkgs/affine-block-frame/translations.js';
+import { IMAGE_WORDINGS } from './_pkgs/affine-block-image/translations.js';
+import { EXEMPTION_FALLBACK, PROVENANCE_FALLBACK, SEVERITY_FALLBACK, SVG_SKETCH_WORDINGS, } from './_pkgs/affine-block-surface/index.js';
+import { SURFACE_REF_CHROME_WORDINGS, SURFACE_REF_WORDINGS, } from './_pkgs/affine-block-surface-ref/translations.js';
+import { ADAPTER_PANEL_WORDINGS } from './_pkgs/affine-fragment-adapter-panel/translations.js';
+import { DOC_TITLE_WORDINGS } from './_pkgs/affine-fragment-doc-title/translations.js';
+import { OUTLINE_WORDINGS } from './_pkgs/affine-fragment-outline/translations.js';
+import { COMPONENTS_WORDINGS } from './_pkgs/affine-components/translations.js';
+import { ROOT_CHROME_WORDINGS, ROOT_SEED_WORDINGS, } from './_pkgs/affine-block-root/translations.js';
+import { BRUSH_WORDINGS } from './_pkgs/affine-gfx-brush/translations.js';
+import { CONNECTOR_WORDINGS } from './_pkgs/affine-gfx-connector/translations.js';
+import { GROUP_CHROME_WORDINGS, GROUP_WORDINGS, } from './_pkgs/affine-gfx-group/translations.js';
+import { MINDMAP_CHROME_WORDINGS, MINDMAP_SEED_WORDINGS, } from './_pkgs/affine-gfx-mindmap/translations.js';
+import { SHAPE_WORDINGS } from './_pkgs/affine-gfx-shape/translations.js';
+import { POINTER_WORDINGS } from './_pkgs/affine-gfx-pointer/translations.js';
+import { FRAME_PANEL_WORDINGS } from './_pkgs/affine-fragment-frame-panel/translations.js';
+import { TEMPLATE_PACKAGE_WORDINGS, TEMPLATE_SEED_WORDINGS, } from './_pkgs/affine-gfx-template/translations.js';
+import { TEXT_WORDINGS } from './_pkgs/affine-gfx-text/translations.js';
+import { LATEX_WORDINGS as INLINE_LATEX_WORDINGS } from './_pkgs/affine-inline-latex/translations.js';
+import { LINK_WORDINGS } from './_pkgs/affine-inline-link/translations.js';
+import { MENTION_WORDINGS } from './_pkgs/affine-inline-mention/translations.js';
+import { PRESET_WORDINGS } from './_pkgs/affine-inline-preset/translations.js';
+import { REFERENCE_WORDINGS } from './_pkgs/affine-inline-reference/translations.js';
+import { CHROME_WORDINGS, } from './_pkgs/affine-shared/services/index.js';
+import { CALLOUT_WORDINGS } from './_pkgs/affine-block-callout/translations.js';
+import { CODE_WORDINGS } from './_pkgs/affine-block-code/translations.js';
+import { LATEX_WORDINGS } from './_pkgs/affine-block-latex/translations.js';
+import { NOTE_WORDINGS } from './_pkgs/affine-block-note/translations.js';
+import { PARAGRAPH_WORDINGS } from './_pkgs/affine-block-paragraph/translations.js';
+import { GFX_NOTE_WORDINGS } from './_pkgs/affine-gfx-note/translations.js';
+import { DRAG_HANDLE_WORDINGS } from './_pkgs/affine-widget-drag-handle/translations.js';
+import { AUTO_CONNECT_WORDINGS } from './_pkgs/affine-widget-edgeless-auto-connect/translations.js';
+import { EDGELESS_SELECTED_RECT_WORDINGS } from './_pkgs/affine-widget-edgeless-selected-rect/translations.js';
+import { EDGELESS_TOOLBAR_WORDINGS } from './_pkgs/affine-widget-edgeless-toolbar/translations.js';
+import { ZOOM_TOOLBAR_WORDINGS } from './_pkgs/affine-widget-edgeless-zoom-toolbar/translations.js';
+import { LINKED_DOC_WORDINGS } from './_pkgs/affine-widget-linked-doc/translations.js';
+import { REMOTE_SELECTION_WORDINGS } from './_pkgs/affine-widget-remote-selection/translations.js';
+import { SLASH_MENU_WORDINGS } from './_pkgs/affine-widget-slash-menu/translations.js';
+import { TOOLBAR_WIDGET_WORDINGS } from './_pkgs/affine-widget-toolbar/translations.js';
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from './_pkgs/std/index.js';
+import { STD_WORDINGS } from './_pkgs/std/translations.js';
 import { getCommands } from './commands.js';
 import { FRAMEWORK_DESCRIPTORS } from './frameworks.js';
+/**
+ * The auxiliary bundles' contributions (`AUXILIARY_BUNDLES` in `frameworks.ts`):
+ * packages that ship as their own bundle without being a framework. Same
+ * one-line `{ owner: '<label>', … }` shape as the framework groups, so
+ * `scripts/build-bundles.mjs` strips them from core's copy the same way.
+ */
+const AUXILIARY_TRANSLATION_GROUPS = [
+// One line per bundle: the bundler strips it by its `owner`.
+];
 const FRAMEWORK_TRANSLATION_GROUPS = [];
 /**
  * The chrome wordings that are TABLES: closed enumerations whose key is a
@@ -87,7 +138,10 @@ const CHROME_KEYS = [
     // Artefact catalogue sidepanel
     ['com.labre.catalogue.title', 'Artefacts'],
     ['com.labre.catalogue.close', 'Close'],
-    ['com.labre.catalogue.other', 'Other'],
+    // `com.labre.catalogue.other` USED to be here — L7 dedupe moved it to
+    // `chrome.ts` (`CATALOGUE_OTHER`), the same word as the templates-panel's
+    // own "Other" category tab, and its one call site now imports the constant
+    // instead of restating the literal.
     ['com.labre.catalogue.ranked', 'Recent & frequent'],
     // Qualify (tags) toolbar
     ['com.labre.tags.toolbar.label', 'Qualify'],
@@ -165,6 +219,14 @@ const CHROME_KEYS = [
     // and would leave every new format silently untranslated.
     ['com.labre.interchange.import.done', 'file imported'],
     ['com.labre.interchange.import.failed', 'This file could not be imported'],
+    // Rights lost WHILE the file was being read — the import's own sentence,
+    // because nothing is wrong with the file. It rides under the same "could not
+    // be imported" headline as a reader's refusal, which is what it is to the
+    // person who picked it.
+    [
+        'com.labre.interchange.import.readonly',
+        'This document became read-only while the file was being read, so nothing was imported.',
+    ],
     [
         'com.labre.interchange.import.remarks',
         'What the import could not keep as it was',
@@ -180,6 +242,90 @@ const CHROME_KEYS = [
     ['com.labre.interchange.import.drawn', 'drawn'],
     ['com.labre.interchange.import.carried', 'carried'],
     ['com.labre.interchange.import.quarantined', 'quarantined'],
+    // The one remark the shared materializer raises itself — a provisional name
+    // two imported elements were both handed. It belongs here with the pipeline's
+    // other words rather than in a reader's table, because no reader produces it:
+    // `materializeInterchangeImport` does, whichever format was read.
+    [
+        'com.labre.interchange.import.duplicate-provisional-name',
+        'Two imported elements were handed the same provisional name "{{name}}". Both are on the board; anything referring to that name points at the first of them.',
+    ],
+];
+/**
+ * The block and widget packages' own wordings — one `readonly ChromeWording[]`
+ * per package, declared in that package's `translations.ts` beside the code
+ * that renders them, and walked here rather than restated.
+ *
+ * Per package and not one central table because the wordings belong to the
+ * package that renders them (an image toolbar's "Download" is the image
+ * block's), and because a single file every block edits is a file every
+ * parallel change conflicts on. Framework wordings do NOT go here: they travel
+ * in the framework's own `…TranslationEntries`, so a bundled host gets them
+ * with the framework bundle.
+ */
+const PACKAGE_WORDINGS = [
+    SLASH_MENU_WORDINGS,
+    OUTLINE_WORDINGS,
+    TEMPLATE_PACKAGE_WORDINGS,
+    NOTE_WORDINGS,
+    GFX_NOTE_WORDINGS,
+    CODE_WORDINGS,
+    LATEX_WORDINGS,
+    CALLOUT_WORDINGS,
+    PARAGRAPH_WORDINGS,
+    ADAPTER_PANEL_WORDINGS,
+    DOC_TITLE_WORDINGS,
+    SHAPE_WORDINGS,
+    TEXT_WORDINGS,
+    MINDMAP_CHROME_WORDINGS,
+    DRAG_HANDLE_WORDINGS,
+    AUTO_CONNECT_WORDINGS,
+    EDGELESS_SELECTED_RECT_WORDINGS,
+    EDGELESS_TOOLBAR_WORDINGS,
+    ZOOM_TOOLBAR_WORDINGS,
+    LINKED_DOC_WORDINGS,
+    REMOTE_SELECTION_WORDINGS,
+    TOOLBAR_WIDGET_WORDINGS,
+    COMPONENTS_WORDINGS,
+    INLINE_LATEX_WORDINGS,
+    LINK_WORDINGS,
+    MENTION_WORDINGS,
+    PRESET_WORDINGS,
+    REFERENCE_WORDINGS,
+    BRUSH_WORDINGS,
+    CONNECTOR_WORDINGS,
+    GROUP_CHROME_WORDINGS,
+    POINTER_WORDINGS,
+    ROOT_CHROME_WORDINGS,
+    SVG_SKETCH_WORDINGS,
+    STD_WORDINGS,
+    ATTACHMENT_WORDINGS,
+    BOOKMARK_WORDINGS,
+    IMAGE_WORDINGS,
+    EMBED_WORDINGS,
+    EMBED_DOC_WORDINGS,
+    SURFACE_REF_CHROME_WORDINGS,
+    FRAME_CHROME_WORDINGS,
+    FRAME_PANEL_WORDINGS,
+];
+/**
+ * Like {@link PACKAGE_WORDINGS}, for a non-framework package's SEEDS: text a
+ * creation action writes INTO the document, not chrome. Kept as its own
+ * source rather than folded into `PACKAGE_WORDINGS` under `chrome` — the two
+ * answer different questions for a host building a catalogue: a seed is
+ * translated once and becomes document content forever (a document created
+ * before the key existed keeps its plain text), while a chrome wording is
+ * re-rendered on every locale switch. `manifest.unit.spec.ts`'s "a placed
+ * artefact is seeded through the seam" pins a few of these by key, exactly as
+ * it does for a framework's own seeds.
+ */
+const PACKAGE_SEED_WORDINGS = [
+    FRAME_WORDINGS,
+    GROUP_WORDINGS,
+    MINDMAP_SEED_WORDINGS,
+    SURFACE_REF_WORDINGS,
+    TEMPLATE_SEED_WORDINGS,
+    ROOT_SEED_WORDINGS,
 ];
 /**
  * Every i18n key THIS package can ask the host for, with its English fallback
@@ -195,13 +341,13 @@ const CHROME_KEYS = [
  * not filtered either.
  */
 export function getTranslationKeyManifest() {
-    return mergeTranslationEntries(commandTranslationEntries(getCommands()), collectTranslationKeys('framework', FRAMEWORK_DESCRIPTORS), ...FRAMEWORK_TRANSLATION_GROUPS.map(group => group.entries), chromeTableEntries(), catalogueCategoryEntries(), 
+    return mergeTranslationEntries(commandTranslationEntries(getCommands()), collectTranslationKeys('framework', FRAMEWORK_DESCRIPTORS), ...FRAMEWORK_TRANSLATION_GROUPS.map(group => group.entries), ...AUXILIARY_TRANSLATION_GROUPS.map(group => group.entries), chromeTableEntries(), catalogueCategoryEntries(), 
     // The editor's own shared vocabulary — the toasts, the toolbar verbs, the
     // view switcher, the board tooltips — DECLARED in
     // `@labre/affine-shared/services` beside nothing at all, and walked here
     // rather than restated. Same rule as the tables above: a wording added to
     // `CHROME_WORDINGS` reaches a host with no second edit.
-    CHROME_WORDINGS.map(([key, fallback]) => ({
+    [...CHROME_WORDINGS, ...PACKAGE_WORDINGS.flat()].map(([key, fallback]) => ({
         key,
         fallback,
         source: 'chrome',
@@ -209,5 +355,14 @@ export function getTranslationKeyManifest() {
         key,
         fallback,
         source: 'chrome',
+    })), 
+    // The non-framework packages' own SEEDS — text a creation action writes
+    // INTO the document (a frame's default title, a starter mindmap's
+    // captions), never re-rendered once placed. See
+    // `PACKAGE_SEED_WORDINGS`.
+    PACKAGE_SEED_WORDINGS.flat().map(([key, fallback]) => ({
+        key,
+        fallback,
+        source: 'seed',
     })));
 }