@formicoidea/labre-core 0.38.2 → 0.39.3

package/dist/_pkgs/affine-gfx-connector/connector-manager.d.ts

@@ -84,7 +84,19 @@ export declare class ConnectorPathGenerator extends PathGenerator {
     constructor(options: {
         getElementById: (id: string) => GfxModel | null;
     });
-    static updatePath(connector: ConnectorElementModel | LocalConnectorElementModel, path: PointLocation[] | null, elementGetter?: (id: string) => GfxModel | null): void;
+    static updatePath(connector: ConnectorElementModel | LocalConnectorElementModel, path: PointLocation[] | null, elementGetter?: (id: string) => GfxModel | null, options?: {
+        /**
+         * Whether this peer may persist the derived label box. `labelXYWH` is a
+         * `@field()`: unlike `path` / `xywh`, which are `@local()` and must be
+         * recomputed everywhere to repaint, writing it makes the CRDT grow on
+         * every peer that merely WATCHES a connector move — and throws on a
+         * readonly viewer. The authoring peer's value arrives with the sync, so
+         * a peer reacting to a remote change passes `false`. Defaults to `true`
+         * for the direct callers (paste, mindmap layout, shape resize), which
+         * are local gestures by construction.
+         */
+        persistLabelXYWH?: boolean;
+    }): void;
     private _computeStartEndPoint;
     private _generateConnectorPath;
     private _generateCurveConnectorPath;

package/dist/_pkgs/affine-gfx-connector/connector-manager.js

@@ -978,7 +978,7 @@ export class ConnectorPathGenerator extends PathGenerator {
         super();
         this.options = options;
     }
-    static updatePath(connector, path, elementGetter) {
+    static updatePath(connector, path, elementGetter, options) {
         const instance = new ConnectorPathGenerator({
             getElementById: elementGetter ?? (() => null),
         });
@@ -1004,12 +1004,16 @@ export class ConnectorPathGenerator extends PathGenerator {
         // the property assignment order matters
         connector.xywh = bound.serialize();
         connector.path = relativePoints;
-        // Updates Connector's Label position.
+        // Updates Connector's Label position — a PERSISTED write, unlike
+        // everything above it.
         if (isConnectorWithLabel(connector)) {
             const model = connector;
-            const [cx, cy] = model.getPointByOffsetDistance(model.labelOffset.distance);
-            const [, , w, h] = model.labelXYWH;
-            model.labelXYWH = [cx - w / 2, cy - h / 2, w, h];
+            const mayPersist = (options?.persistLabelXYWH ?? true) && !model.surface?.store?.readonly;
+            if (mayPersist) {
+                const [cx, cy] = model.getPointByOffsetDistance(model.labelOffset.distance);
+                const [, , w, h] = model.labelXYWH;
+                model.labelXYWH = [cx - w / 2, cy - h / 2, w, h];
+            }
         }
         connector.updatingPath = false;
     }

package/dist/_pkgs/affine-gfx-connector/connector-watcher.js

@@ -62,49 +62,74 @@ function reanchorConnectorsForPolygon(surface, polygonId, elementGetter) {
 export const connectorWatcher = (surface) => {
     const hasElementById = (id) => surface.hasElementById(id) || surface.store.hasBlock(id);
     const elementGetter = (id) => surface.getElementById(id) ?? surface.store.getModelById(id);
-    const updateConnectorPath = (connector) => {
+    const updateConnectorPath = (connector, local) => {
         if (((connector.source?.id && hasElementById(connector.source.id)) ||
             (!connector.source?.id && connector.source?.position)) &&
             ((connector.target?.id && hasElementById(connector.target.id)) ||
                 (!connector.target?.id && connector.target?.position))) {
-            ConnectorPathGenerator.updatePath(connector, null, elementGetter);
+            // The path itself is `@local()` — every peer recomputes it to repaint.
+            // The label box is not: only the peer that authored the change persists
+            // it, the others read the value that arrives with the sync.
+            ConnectorPathGenerator.updatePath(connector, null, elementGetter, {
+                persistLabelXYWH: local,
+            });
         }
     };
-    const pendingList = new Set();
+    /**
+     * Connectors whose path must be recomputed in the next microtask, mapped to
+     * whether ANY of the changes that queued them was local — a single local
+     * gesture is enough to let the peer persist the derived label box.
+     */
+    const pendingList = new Map();
     let pendingFlag = false;
-    const addToUpdateList = (connector) => {
-        pendingList.add(connector);
+    const addToUpdateList = (connector, local) => {
+        pendingList.set(connector, (pendingList.get(connector) ?? false) || local);
         if (!pendingFlag) {
             pendingFlag = true;
             queueMicrotask(() => {
-                pendingList.forEach(updateConnectorPath);
+                pendingList.forEach((isLocal, connector) => updateConnectorPath(connector, isLocal));
                 pendingList.clear();
                 pendingFlag = false;
             });
         }
     };
     const disposables = [
-        surface.elementAdded.subscribe(({ id }) => {
+        surface.elementAdded.subscribe(({ id, local }) => {
             const element = elementGetter(id);
             if (!element)
                 return;
             if ('type' in element && element.type === 'connector') {
-                addToUpdateList(element);
+                addToUpdateList(element, local);
             }
             else {
-                surface.getConnectors(id).forEach(addToUpdateList);
+                surface
+                    .getConnectors(id)
+                    .forEach(connector => addToUpdateList(connector, local));
             }
         }),
-        surface.elementUpdated.subscribe(({ id, props }) => {
+        surface.elementUpdated.subscribe(({ id, props, local }) => {
             const element = elementGetter(id);
-            if (props['vertices']) {
+            // The element may already be gone by the time the update is delivered
+            // (a remote peer that moved and then deleted it, an undo…).
+            if (!element)
+                return;
+            if (local && props['vertices']) {
                 // When polygon vertices change, re-anchor connected connectors to the
                 // nearest valid boundary point BEFORE scheduling the path update, so
                 // the path generator uses the corrected anchor positions.
+                //
+                // LOCAL ONLY: re-anchoring writes `source`/`target`, both persisted
+                // `@field()`s. The peer that edited the vertices re-anchors and syncs
+                // the result, so doing it again on a receiving peer is a duplicate
+                // write — and an illegal one on a readonly viewer (see #242).
                 reanchorConnectorsForPolygon(surface, id, elementGetter);
             }
             if (props['xywh'] || props['rotate'] || props['vertices']) {
-                surface.getConnectors(id).forEach(addToUpdateList);
+                // Not gated on `local`: `path`, `absolutePath` and the connector's own
+                // `xywh` are `@local()`, so every peer must recompute them to repaint.
+                surface
+                    .getConnectors(id)
+                    .forEach(connector => addToUpdateList(connector, local));
             }
             if ('type' in element &&
                 element.type === 'connector' &&
@@ -113,25 +138,31 @@ export const connectorWatcher = (surface) => {
                     props['source'] ||
                     props['curveControlPoint'] !== undefined)) {
                 const connector = element;
-                // Clear custom handle data when connector mode changes
-                if (props['mode'] !== undefined) {
+                // Clear custom handle data when connector mode changes. `local` only:
+                // `curveControlPoint` is persisted, and the peer that changed the mode
+                // cleared it in the same gesture.
+                if (local && props['mode'] !== undefined) {
                     if (connector.curveControlPoint !== null) {
                         connector.curveControlPoint = null;
                     }
                 }
-                addToUpdateList(connector);
+                addToUpdateList(connector, local);
             }
         }),
         surface.store.slots.blockUpdated.subscribe(payload => {
             if (payload.type === 'add' ||
                 (payload.type === 'update' && payload.props.key === 'xywh')) {
-                surface.getConnectors(payload.id).forEach(addToUpdateList);
+                surface
+                    .getConnectors(payload.id)
+                    .forEach(connector => addToUpdateList(connector, payload.isLocal));
             }
         }),
     ];
+    // Mount-time recompute of the `@local()` geometry. Not a local gesture:
+    // merely OPENING a document must not rewrite every connector's label box.
     surface
         .getElementsByType('connector')
-        .forEach(connector => updateConnectorPath(connector));
+        .forEach(connector => updateConnectorPath(connector, false));
     return () => {
         disposables.forEach(d => d.unsubscribe());
     };

package/dist/_pkgs/affine-gfx-connector/view/view.js

@@ -44,7 +44,11 @@ export class ConnectorElementView extends GfxElementModelView {
             };
         };
         const watchEvent = (labelModel) => {
+            // `ViewManager.get` returns null for an element that has no view yet —
+            // the local label element is registered a beat before its view exists.
             const view = this.gfx.view.get(labelModel);
+            if (!view)
+                return;
             const connectorModel = this.model;
             let labelBound = null;
             let startPoint = {

package/dist/_pkgs/affine-gfx-mindmap/view/view.js

@@ -173,12 +173,18 @@ export class MindMapView extends GfxElementModelView {
                 button: false,
                 node: false,
             };
+            this._hoveredState = this._hoveredState.set(node.id, hoveredState);
+            // `ViewManager.get` returns null for an element whose view is not
+            // mounted yet — the button model exists a beat before its view does.
+            // The button is created and tracked either way; only the hover wiring
+            // is skipped.
             const buttonView = this.gfx.view.get(id);
+            if (!buttonView)
+                return collapseButton;
             const isOnElementBound = (evt) => {
                 const [x, y] = this.gfx.viewport.toModelCoord(evt.x, evt.y);
                 return buttonView.model.includesPoint(x, y, { useElementBound: true }, this.gfx.std.host);
             };
-            this._hoveredState = this._hoveredState.set(node.id, hoveredState);
             buttonView.on('pointerenter', () => {
                 hoveredState.button = true;
                 this._updateButtonVisibility(node.id);
@@ -216,6 +222,8 @@ export class MindMapView extends GfxElementModelView {
                 }
             });
             const nodeView = this.gfx.view.get(node.id);
+            if (!nodeView)
+                return collapseButton;
             nodeView.on('pointerenter', () => {
                 hoveredState.node = true;
                 this._updateButtonVisibility(node.id);

package/dist/_pkgs/affine-gfx-mindmap/view.js

@@ -1,5 +1,5 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
-import { extendTemplateCategory } from '../affine-gfx-template/index.js';
+import { TemplateCategoryExtension } from '../affine-gfx-template/index.js';
 import { effects } from './effects.js';
 import { MindmapElementRendererExtension } from './element-renderer.js';
 import { MindMapIndicatorOverlay } from './indicator-overlay/index.js';
@@ -22,7 +22,6 @@ export class MindmapRenderViewExtension extends ViewExtensionProvider {
     effect() {
         super.effect();
         effects();
-        extendTemplateCategory(mindmapTemplateCategory);
     }
     setup(context) {
         super.setup(context);
@@ -33,6 +32,12 @@ export class MindmapRenderViewExtension extends ViewExtensionProvider {
         context.register(MindMapDragExtension);
         context.register(MindMapIndicatorOverlay);
         context.register(MindMapInteraction);
+        if (this.isEdgeless(context.scope)) {
+            // The Mind Map Templates-panel category stays on the ALWAYS-ON half, on
+            // purpose: it must survive the `mindmap` flag, which only hides the
+            // senior button ({@link MindmapToolViewExtension}).
+            context.register(TemplateCategoryExtension(mindmapTemplateCategory));
+        }
     }
 }
 /** The dedicated "Mind Map" senior button — flag-gated (`mindmap`). */

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

@@ -1,9 +1,34 @@
-import type { TemplateCategory } from './toolbar/template-type.js';
+import type { BlockStdScope } from '../std/index.js';
+import type { ExtensionType } from '../store/index.js';
+import type { TemplateCategory, TemplateManager } from './toolbar/template-type.js';
 /**
- * Contribute a template category to the edgeless template panel. Idempotent per
- * category name (a framework's ViewExtension `effect()` may run more than once).
- * Lets each framework package own its template definitions while the panel
- * aggregates every contributed category. The future favorites feature reads the
- * same registry to decide which framework toolbars to show.
+ * 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
+ * category NAME, so two extensions claiming the same category collide at
+ * setup (`DuplicateServiceDefinitionError`, caught by `di-mount.unit.spec.ts`)
+ * rather than listing it twice.
  */
-export declare function extendTemplateCategory(category: TemplateCategory): void;
+export declare const TemplateCategoryIdentifier: import("../global/di/types.js").ServiceIdentifier<TemplateCategory> & (<U extends TemplateCategory = TemplateCategory>(variant: import("../global/di/types.js").ServiceVariant) => import("../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Register a framework's template categories. Call it from `setup()` of the
+ * FLAG-GATED view extension, beside the senior tool — a category is creation
+ * tooling, so a disabled framework must contribute none (`docs/adr/0009`):
+ *
+ * ```ts
+ * context.register(TemplateCategoryExtension(wardleyTemplateCategory));
+ * ```
+ *
+ * Replaces the module-level registry of 0.38.0–0.38.2 (`extendTemplateCategory`)
+ * that appended from `effect()` and never removed: a category outlived the
+ * editor whose flags had admitted it, so a framework switched off in the host
+ * kept its category until a full reload (#244). The DI container is per editor;
+ * nothing has to be un-registered.
+ */
+export declare function TemplateCategoryExtension(...categories: TemplateCategory[]): ExtensionType;
+/**
+ * The catalogue ONE editor sees: the built-in categories (`Other`, plus
+ * whatever a host appended through `EdgelessTemplatePanel.templates.extend`)
+ * followed by the categories the view extensions mounted on this `std`
+ * registered — i.e. exactly the frameworks whose tooling is on.
+ */
+export declare function templateManagerFor(std: BlockStdScope): TemplateManager;

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

@@ -1,32 +1,76 @@
-import { EdgelessTemplatePanel } from './toolbar/template-panel.js';
+import { createIdentifier } from '../global/di/index.js';
+import { builtInTemplates } from './toolbar/builtin-templates.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
+ * category NAME, so two extensions claiming the same category collide at
+ * setup (`DuplicateServiceDefinitionError`, caught by `di-mount.unit.spec.ts`)
+ * rather than listing it twice.
+ */
+export const TemplateCategoryIdentifier = createIdentifier('TemplateCategory');
+/**
+ * Register a framework's template categories. Call it from `setup()` of the
+ * FLAG-GATED view extension, beside the senior tool — a category is creation
+ * tooling, so a disabled framework must contribute none (`docs/adr/0009`):
+ *
+ * ```ts
+ * context.register(TemplateCategoryExtension(wardleyTemplateCategory));
+ * ```
+ *
+ * Replaces the module-level registry of 0.38.0–0.38.2 (`extendTemplateCategory`)
+ * that appended from `effect()` and never removed: a category outlived the
+ * editor whose flags had admitted it, so a framework switched off in the host
+ * kept its category until a full reload (#244). The DI container is per editor;
+ * nothing has to be un-registered.
+ */
+export function TemplateCategoryExtension(...categories) {
+    return {
+        setup: di => {
+            for (const category of categories) {
+                di.addImpl(TemplateCategoryIdentifier(category.name), () => category);
+            }
+        },
+    };
+}
 function loadCategory(category) {
     return Array.isArray(category.templates)
         ? Promise.resolve(category.templates)
         : category.templates();
 }
-/** Wrap a single {@link TemplateCategory} as a {@link TemplateManager}. */
-function categoryManager(category) {
+/**
+ * The catalogue ONE editor sees: the built-in categories (`Other`, plus
+ * whatever a host appended through `EdgelessTemplatePanel.templates.extend`)
+ * followed by the categories the view extensions mounted on this `std`
+ * registered — i.e. exactly the frameworks whose tooling is on.
+ */
+export function templateManagerFor(std) {
+    const contributed = [
+        ...std.provider.getAll(TemplateCategoryIdentifier).values(),
+    ];
+    const byName = (name) => contributed.find(c => c.name === name);
     return {
-        categories: () => [category.name],
-        list: async (cate) => cate === category.name ? await loadCategory(category) : [],
-        search: async (keyword) => {
-            const all = await loadCategory(category);
+        categories: async () => [
+            ...new Set([
+                ...(await builtInTemplates.categories()),
+                ...contributed.map(c => c.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) => {
+            const category = byName(name);
+            return [
+                ...(category ? await loadCategory(category) : []),
+                ...(await builtInTemplates.list(name)),
+            ];
+        },
+        search: async (keyword, name) => {
             const k = keyword.trim().toLocaleLowerCase();
-            return all.filter(t => t.name?.toLocaleLowerCase().includes(k));
+            const pool = name ? [byName(name)].filter(c => !!c) : contributed;
+            const own = (await Promise.all(pool.map(loadCategory)))
+                .flat()
+                .filter(t => t.name?.toLocaleLowerCase().includes(k));
+            return [...(await builtInTemplates.search(keyword, name)), ...own];
         },
     };
 }
-const registered = new Set();
-/**
- * Contribute a template category to the edgeless template panel. Idempotent per
- * category name (a framework's ViewExtension `effect()` may run more than once).
- * Lets each framework package own its template definitions while the panel
- * aggregates every contributed category. The future favorites feature reads the
- * same registry to decide which framework toolbars to show.
- */
-export function extendTemplateCategory(category) {
-    if (registered.has(category.name))
-        return;
-    registered.add(category.name);
-    EdgelessTemplatePanel.templates.extend(categoryManager(category));
-}

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

@@ -5,12 +5,19 @@ import type { Template } from './template-type.js';
 declare const EdgelessTemplatePanel_base: typeof LitElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
 export declare class EdgelessTemplatePanel extends EdgelessTemplatePanel_base {
     static styles: import("lit").CSSResult;
+    /**
+     * The GLOBAL half of the catalogue — `Other` and a host's `extend(...)`.
+     * Framework categories are not here: they live in the editor's DI container
+     * (`TemplateCategoryExtension`) and are read through {@link catalogue}.
+     */
     static templates: {
         list: (category: string) => Promise<Template[]>;
         categories: () => Promise<string[]>;
         search: (keyword: string, cateName?: string) => Promise<Template[]>;
         extend(manager: import("./template-type.js").TemplateManager): void;
     };
+    /** What THIS edgeless offers: the global half plus its std's categories. */
+    get catalogue(): import("./template-type.js").TemplateManager;
     private _fetchJob;
     draggableController: EdgelessDraggableElementController<Template>;
     private _closePanel;

package/dist/_pkgs/affine-gfx-template/toolbar/template-panel.js

@@ -45,6 +45,7 @@ import { property, state } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import { unsafeSVG } from 'lit/directives/unsafe-svg.js';
+import { templateManagerFor } from '../contribute.js';
 import { createTemplateJob } from '../services/template.js';
 import { builtInTemplates } from './builtin-templates.js';
 import { defaultPreview, Triangle } from './cards.js';
@@ -261,7 +262,16 @@ let EdgelessTemplatePanel = (() => {
       color: var(--affine-background-overlay-panel-color);
     }
   `; }
+        /**
+         * The GLOBAL half of the catalogue — `Other` and a host's `extend(...)`.
+         * Framework categories are not here: they live in the editor's DI container
+         * (`TemplateCategoryExtension`) and are read through {@link catalogue}.
+         */
         static { this.templates = builtInTemplates; }
+        /** What THIS edgeless offers: the global half plus its std's categories. */
+        get catalogue() {
+            return templateManagerFor(this.edgeless.std);
+        }
         _closePanel() {
             if (this.isDragging)
                 return;
@@ -293,9 +303,14 @@ let EdgelessTemplatePanel = (() => {
         }
         async _initCategory() {
             try {
-                this._categories = await EdgelessTemplatePanel.templates.categories();
+                this._categories = await this.catalogue.categories();
+                // The remembered tab may belong to a framework this editor no longer
+                // registers (switched off since): fall back rather than show an empty list.
+                const remembered = this._getLocalSelectedCategory();
                 this._currentCategory =
-                    this._getLocalSelectedCategory() ?? this._categories[0];
+                    remembered && this._categories.includes(remembered)
+                        ? remembered
+                        : this._categories[0];
                 this._updateTemplates();
             }
             catch (e) {
@@ -366,8 +381,8 @@ let EdgelessTemplatePanel = (() => {
             this._fetch(async (state) => {
                 try {
                     const templates = this._searchKeyword
-                        ? await EdgelessTemplatePanel.templates.search(this._searchKeyword)
-                        : await EdgelessTemplatePanel.templates.list(this._currentCategory);
+                        ? await this.catalogue.search(this._searchKeyword)
+                        : await this.catalogue.list(this._currentCategory);
                     if (state.canceled)
                         return;
                     this._templates = templates;

package/dist/_pkgs/affine-model/elements/mindmap/mindmap.js

@@ -57,7 +57,16 @@ function isNodeType(node) {
 }
 function observeChildren(_, instance, transaction) {
     if (instance.children.doc) {
-        instance.setChildIds(Array.from(instance.children.keys()), transaction?.local ?? true);
+        // `?? false`, like every other group-like element (see `group.ts`): a
+        // missing transaction is NOT a local gesture. `startObserve` re-runs this
+        // observer with `transaction === null` whenever the `children` key itself
+        // is rewritten — by a remote peer, a snapshot import or an undo — and
+        // reporting that as local makes the group watchers treat a received change
+        // as one this peer just made: they delete an emptied mindmap locally,
+        // which a readonly viewer cannot do (#251, rule from #242).
+        instance.setChildIds(Array.from(instance.children.keys()), transaction?.local ?? false);
+        // Pure local recompute, no CRDT write: unconditional on purpose, every
+        // peer must rebuild its tree to repaint.
         instance.buildTree();
         instance.connectors.clear();
     }

package/dist/_pkgs/affine-shared/adapters/middlewares/proxy.d.ts

@@ -2,7 +2,17 @@ import type { TransformerMiddleware } from '../../../store/index.js';
 import { StoreExtension } from '../../../store/index.js';
 export declare const customImageProxyMiddleware: (imageProxyURL: string) => TransformerMiddleware;
 export declare const setImageProxyMiddlewareURL: (url: string) => void;
+/**
+ * Reads the URL at run time: a `setImageProxyURL` made after module load
+ * reaches every job using this middleware.
+ */
 export declare const defaultImageProxyMiddleware: TransformerMiddleware;
+/**
+ * The ONE seam governing every remote-image fetch the library performs on the
+ * host's behalf: link-card favicons and og:images, image import, canvas
+ * PNG/PDF export, copy-as-image. An empty URL means « fetch direct ».
+ * See `docs/integrate/04-host-seams.md`.
+ */
 export declare class ImageProxyService extends StoreExtension {
     static key: string;
     private _imageProxyURL;

package/dist/_pkgs/affine-shared/adapters/middlewares/proxy.js

@@ -5,18 +5,25 @@ export const customImageProxyMiddleware = (imageProxyURL) => {
         adapterConfigs.set('imageProxy', imageProxyURL);
     };
 };
-const imageProxyMiddlewareBuilder = () => {
-    let middleware = customImageProxyMiddleware(DEFAULT_IMAGE_PROXY_ENDPOINT);
-    return {
-        get: () => middleware,
-        set: (url) => {
-            middleware = customImageProxyMiddleware(url);
-        },
-    };
+// Module-wide so that transformer jobs built outside a store (playground
+// panels, host-side importers) follow `setImageProxyURL` too.
+let imageProxyMiddlewareURL = DEFAULT_IMAGE_PROXY_ENDPOINT;
+export const setImageProxyMiddlewareURL = (url) => {
+    imageProxyMiddlewareURL = url;
+};
+/**
+ * Reads the URL at run time: a `setImageProxyURL` made after module load
+ * reaches every job using this middleware.
+ */
+export const defaultImageProxyMiddleware = ({ adapterConfigs, }) => {
+    adapterConfigs.set('imageProxy', imageProxyMiddlewareURL);
 };
-const defaultImageProxyMiddlewarBuilder = imageProxyMiddlewareBuilder();
-export const setImageProxyMiddlewareURL = defaultImageProxyMiddlewarBuilder.set;
-export const defaultImageProxyMiddleware = defaultImageProxyMiddlewarBuilder.get();
+/**
+ * The ONE seam governing every remote-image fetch the library performs on the
+ * host's behalf: link-card favicons and og:images, image import, canvas
+ * PNG/PDF export, copy-as-image. An empty URL means « fetch direct ».
+ * See `docs/integrate/04-host-seams.md`.
+ */
 // TODO(@mirone): this should be configured when setup instead of runtime
 export class ImageProxyService extends StoreExtension {
     constructor() {
@@ -29,7 +36,7 @@ export class ImageProxyService extends StoreExtension {
         setImageProxyMiddlewareURL(url);
     }
     buildUrl(imageUrl) {
-        if (imageUrl.startsWith(this.imageProxyURL)) {
+        if (!this.imageProxyURL || imageUrl.startsWith(this.imageProxyURL)) {
             return imageUrl;
         }
         return `${this.imageProxyURL}?url=${encodeURIComponent(imageUrl)}`;

package/dist/_pkgs/affine-shared/adapters/utils/fetch.js

@@ -12,6 +12,10 @@ const fetchImage = async (url, init, proxy) => {
         if (url.startsWith(window.location.origin)) {
             return await fetch(url, init);
         }
+        // Already proxied (a link card renders `buildUrl(...)`): do not wrap twice.
+        if (url.startsWith(proxy)) {
+            return await fetch(url, init);
+        }
         return await fetch(proxy + '?url=' + encodeURIComponent(url), init)
             .then(res => {
             if (!res.ok) {

package/dist/_pkgs/affine-widget-keyboard-toolbar/widget.js

@@ -7,6 +7,13 @@ import { html, nothing } from 'lit';
 import { literal, unsafeStatic } from 'lit/static-html.js';
 import { defaultKeyboardToolbarConfig, KeyboardToolbarConfigExtension, } from './config.js';
 export const AFFINE_KEYBOARD_TOOLBAR_WIDGET = 'affine-keyboard-toolbar-widget';
+/**
+ * Signals backing the fallback keyboard, at module level on purpose: the
+ * `keyboard` getter is read from `render()`, so a fresh `signal()` per call
+ * would hand `PositionController`'s effect a brand new object every frame.
+ */
+const fallbackKeyboardVisible$ = signal(false);
+const fallbackKeyboardHeight$ = signal(0);
 export class AffineKeyboardToolbarWidget extends WidgetComponent {
     constructor() {
         super(...arguments);
@@ -26,12 +33,20 @@ export class AffineKeyboardToolbarWidget extends WidgetComponent {
         this._initialInputMode = '';
     }
     get keyboard() {
-        const provider = this.std.get(VirtualKeyboardProvider);
-        if (isVirtualKeyboardProviderWithAction(provider))
+        // The provider is host-supplied — a native mobile shell reports the
+        // on-screen keyboard. Labre ships no such shell, so a plain web host
+        // registers nothing and this lookup must stay optional; a hard `get` throws
+        // and takes the whole document open down with it (issue #247).
+        const provider = this.std.getOptional(VirtualKeyboardProvider);
+        if (provider && isVirtualKeyboardProviderWithAction(provider))
             return provider;
         return {
-            // fallback keyboard actions
+            // Fallback keyboard, complete WITHOUT a provider: the signals come first
+            // so that a provider without actions still wins on them through the
+            // spread below, while its `show`/`hide` stay ours.
             fallback: true,
+            visible$: fallbackKeyboardVisible$,
+            height$: fallbackKeyboardHeight$,
             show: () => {
                 const rootComponent = this.block?.rootComponent;
                 if (rootComponent && rootComponent === document.activeElement) {

package/dist/_pkgs/affine-widget-linked-doc/mobile-linked-doc-menu.d.ts

@@ -13,7 +13,13 @@ export declare class AffineMobileLinkedDocMenu extends AffineMobileLinkedDocMenu
     private readonly _updateLinkedDocGroup;
     private _updateLinkedDocGroupAbortController;
     private get _query();
-    get keyboard(): VirtualKeyboardProvider | import("../affine-shared/services/virtual-keyboard-service.js").VirtualKeyboardProviderWithAction;
+    /**
+     * The virtual keyboard provider is host-supplied — a native mobile shell
+     * reports the on-screen keyboard. Labre ships no such shell, so a plain web
+     * host registers nothing and this lookup must stay optional; a hard `get`
+     * throws and takes the whole document open down with it (issue #247).
+     */
+    get keyboard(): VirtualKeyboardProvider | null;
     connectedCallback(): void;
     firstUpdated(): void;
     render(): import("lit-html").TemplateResult<1> | typeof nothing;

package/dist/_pkgs/affine-widget-linked-doc/mobile-linked-doc-menu.js

@@ -71,8 +71,14 @@ let AffineMobileLinkedDocMenu = (() => {
         get _query() {
             return getTextContentFromInlineRange(this.context.inlineEditor, this.context.startRange);
         }
+        /**
+         * The virtual keyboard provider is host-supplied — a native mobile shell
+         * reports the on-screen keyboard. Labre ships no such shell, so a plain web
+         * host registers nothing and this lookup must stay optional; a hard `get`
+         * throws and takes the whole document open down with it (issue #247).
+         */
         get keyboard() {
-            return this.context.std.get(VirtualKeyboardProvider);
+            return this.context.std.getOptional(VirtualKeyboardProvider) ?? null;
         }
         connectedCallback() {
             super.connectedCallback();
@@ -114,7 +120,7 @@ let AffineMobileLinkedDocMenu = (() => {
             if (groups.length === 0) {
                 return nothing;
             }
-            this.style.bottom = `${this.keyboard.height$.value}px`;
+            this.style.bottom = `${this.keyboard?.height$.value ?? 0}px`;
             return html `
       ${join(groups.map(this._renderGroup), html `<div class="divider"></div>`)}
     `;