@formicoidea/labre-core 0.32.0 → 0.34.1

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

@@ -180,67 +180,67 @@ let ReadingProposalWidget = (() => {
         static { this.styles = [
             editorAnchoredPanelStyles,
             css `
-    .reading-title {
-      font-weight: 600;
-      margin-bottom: 8px;
-    }
+      .reading-title {
+        font-weight: 600;
+        margin-bottom: 8px;
+      }
 
-    .reading-field + .reading-field {
-      margin-top: 10px;
-      padding-top: 10px;
-      border-top: 1px solid var(--affine-border-color);
-    }
+      .reading-field + .reading-field {
+        margin-top: 10px;
+        padding-top: 10px;
+        border-top: 1px solid var(--affine-border-color);
+      }
 
-    .reading-label {
-      color: var(--affine-text-secondary-color);
-      font-size: 11px;
-      text-transform: uppercase;
-      letter-spacing: 0.04em;
-    }
+      .reading-label {
+        color: var(--affine-text-secondary-color);
+        font-size: 11px;
+        text-transform: uppercase;
+        letter-spacing: 0.04em;
+      }
 
-    .reading-value {
-      overflow-wrap: anywhere;
-    }
+      .reading-value {
+        overflow-wrap: anywhere;
+      }
 
-    .reading-empty {
-      color: var(--affine-text-secondary-color);
-      font-style: italic;
-    }
+      .reading-empty {
+        color: var(--affine-text-secondary-color);
+        font-style: italic;
+      }
 
-    .reading-note {
-      margin-top: 2px;
-      color: var(--affine-text-secondary-color);
-      font-size: 13px;
-      overflow-wrap: anywhere;
-    }
+      .reading-note {
+        margin-top: 2px;
+        color: var(--affine-text-secondary-color);
+        font-size: 13px;
+        overflow-wrap: anywhere;
+      }
 
-    .reading-actions {
-      display: flex;
-      flex-wrap: wrap;
-      gap: 8px;
-      margin-top: 8px;
-    }
+      .reading-actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin-top: 8px;
+      }
 
-    .reading-action {
-      padding: 2px 8px;
-      border-radius: 4px;
-      border: 1px solid var(--affine-border-color);
-      background: transparent;
-      color: var(--affine-text-secondary-color);
-      font-family: inherit;
-      font-size: 12px;
-      cursor: pointer;
-    }
+      .reading-action {
+        padding: 2px 8px;
+        border-radius: 4px;
+        border: 1px solid var(--affine-border-color);
+        background: transparent;
+        color: var(--affine-text-secondary-color);
+        font-family: inherit;
+        font-size: 12px;
+        cursor: pointer;
+      }
 
-    .reading-action:hover {
-      background: var(--affine-hover-color);
-      color: var(--affine-text-primary-color);
-    }
+      .reading-action:hover {
+        background: var(--affine-hover-color);
+        color: var(--affine-text-primary-color);
+      }
 
-    .reading-action:focus-visible {
-      outline: 2px solid var(--affine-primary-color);
-      outline-offset: 1px;
-    }
+      .reading-action:focus-visible {
+        outline: 2px solid var(--affine-primary-color);
+        outline-offset: 1px;
+      }
     `,
         ]; }
         #_revision_accessor_storage;
@@ -389,8 +389,7 @@ let ReadingProposalWidget = (() => {
               @click=${this._confirmNature(reading.elementId, tagId, proposed)}
             >
               ${translateKey(this.std, 'com.labre.reading.action.confirm-nature', 'Confirm')}
-              ·
-              ${proposed.map(id => this._natureLabel(tagId, id)).join(', ')}
+              · ${proposed.map(id => this._natureLabel(tagId, id)).join(', ')}
             </button>
           </div>`
                 : nothing}`);
@@ -412,8 +411,7 @@ let ReadingProposalWidget = (() => {
             ${translateKey(this.std, 'com.labre.reading.relations.none', 'No typed link touches this component.')}
           </div>`
                 : nothing}
-      ${line(consumers, 'consumers')}
-      ${line(suppliers, 'suppliers')}
+      ${line(consumers, 'consumers')} ${line(suppliers, 'suppliers')}
       ${contradictions.length
                 ? html `<div class="reading-note" data-testid="reading-contradiction">
             ${translateKey(this.std, 'com.labre.reading.relations.contradiction', 'A link states the opposite of what the positions show')}:
@@ -446,12 +444,12 @@ let ReadingProposalWidget = (() => {
             const from = translateKey(this.std, 'com.labre.reading.value-flow', 'Value flows up from');
             const to = translateKey(this.std, 'com.labre.reading.value-flow.to', 'to');
             return this._field('reading-value-flow', translateKey(this.std, 'com.labre.reading.field.value-flow', 'Value flow'), html `${flows.map(flow => html `<div
-          class="reading-value"
-          data-testid="reading-value-flow-line"
-          data-edge-id=${flow.edgeId}
-        >
-          ${from} ${flow.from} ${to} ${flow.to}
-        </div>`)}`);
+            class="reading-value"
+            data-testid="reading-value-flow-line"
+            data-edge-id=${flow.edgeId}
+          >
+            ${from} ${flow.from} ${to} ${flow.to}
+          </div>`)}`);
         }
         _renderPhase(reading) {
             const { phase } = reading;
@@ -495,25 +493,25 @@ let ReadingProposalWidget = (() => {
             const bound = isPivotBound(element);
             const picker = this.std.getOptional(PivotRecordPickerProvider);
             return this._field('reading-record', translateKey(this.std, 'com.labre.reading.field.record', 'Record'), html `<div class="reading-value">
-        ${bound
+          ${bound
                 ? translateKey(this.std, 'com.labre.reading.record.linked', 'Linked')
                 : html `<span class="reading-empty"
-              >${translateKey(this.std, 'com.labre.reading.record.none', 'Not linked to a record.')}</span
-            >`}
-      </div>
-      ${!bound && picker && writable
+                >${translateKey(this.std, 'com.labre.reading.record.none', 'Not linked to a record.')}</span
+              >`}
+        </div>
+        ${!bound && picker && writable
                 ? html `<div class="reading-actions">
-            <button
-              class="reading-action"
-              type="button"
-              data-testid="reading-link-record"
-              @pointerdown=${this.swallow}
-              @pointerup=${this.swallow}
-              @click=${this._linkRecord(reading.elementId)}
-            >
-              ${translateKey(this.std, 'com.labre.reading.action.link', 'Link to a record')}
-            </button>
-          </div>`
+              <button
+                class="reading-action"
+                type="button"
+                data-testid="reading-link-record"
+                @pointerdown=${this.swallow}
+                @pointerup=${this.swallow}
+                @click=${this._linkRecord(reading.elementId)}
+              >
+                ${translateKey(this.std, 'com.labre.reading.action.link', 'Link to a record')}
+              </button>
+            </div>`
                 : nothing}`);
         }
         /** The drift line: informative, never blocking, with one way to settle it. */
@@ -580,8 +578,8 @@ let ReadingProposalWidget = (() => {
         ${this._renderNodeType(reading, profile)}
         ${this._renderNature(reading, profile, record, writable)}
         ${this._renderRelations(reading)} ${this._renderValueFlow(reading)}
-        ${this._renderPhase(reading)}
-        ${this._renderNaming(reading)} ${this._renderRecord(reading, writable)}
+        ${this._renderPhase(reading)} ${this._renderNaming(reading)}
+        ${this._renderRecord(reading, writable)}
         ${writable ? this._renderDrift(reading) : nothing}`);
         }
     };

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

@@ -1,13 +1,13 @@
 import { getUniverseRegistry, hostLanguage, queryPivotProperties, } from '../../affine-shared/services/index.js';
 import { createIdentifier } from '../../global/di/index.js';
-import { LifeCycleWatcher } from '../../std/index.js';
+import { LifeCycleWatcher, } from '../../std/index.js';
 import { GfxControllerIdentifier, GfxPrimitiveElementModel, isPivotBound, readElementTags, roleIsA, } from '../../std/gfx/index.js';
 import { effect, signal } from '@preact/signals-core';
 // Straight at the two leaf modules rather than at the barrel, for the reason
 // `validation.ts` states: `index.js` also re-exports the RENDERER, and a
 // reading is a one-way read of pure declaration data that must never pull a
 // canvas in.
-import { backgroundPlot } from '../framework-background/def.js';
+import { backgroundPlot, } from '../framework-background/def.js';
 import { backgroundTransitionBands } from '../framework-background/facts.js';
 /** Deepest role chain reported by {@link ReadingNodeType.specialises}. */
 const MAX_ROLE_DEPTH = 32;

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

@@ -1,4 +1,5 @@
 import type { ConnectorElementModel } from '../../affine-model/index.js';
+import type { Bound } from '../../global/gfx/index.js';
 import type { GfxModel } from '../../std/gfx/index.js';
 import { InteractivityExtension } from '../../std/gfx/index.js';
 import type { ExtensionType } from '../../store/index.js';
@@ -25,6 +26,26 @@ export declare function SpotlightHostExtension(elementType: string): ExtensionTy
  * two endpoints). Pure — exported for unit tests.
  */
 export declare function spotlightSet(target: GfxModel, getConnectors: (id: string) => ConnectorElementModel[]): Set<string>;
+/** The shape {@link findSpotlightHost} needs of a candidate host. */
+export type SpotlightHostCandidate = {
+    type: string;
+    elementBound: Bound;
+    spotlightEnabled?: boolean;
+};
+/**
+ * The host that grants `target` the spotlight, or `null` when none does.
+ *
+ * A host qualifies when its type was REGISTERED as a spotlight host
+ * (`SpotlightHostExtension`), when it did not opt out (`spotlightEnabled:
+ * false`, its toolbar toggle) and when its bounds contain the target. A
+ * background whose type is not registered grants nothing, whatever fields it
+ * carries — that is how the EDGY facets Venn stopped spotlighting (#195).
+ *
+ * Pure — exported for unit tests.
+ */
+export declare function findSpotlightHost<T extends SpotlightHostCandidate>(target: {
+    elementBound: Bound;
+}, elements: readonly T[], hostTypes: readonly string[]): T | null;
 export declare class SpotlightManager extends InteractivityExtension {
     static key: string;
     /** Elements currently faded, restored on leave. */

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

@@ -47,6 +47,22 @@ export function spotlightSet(target, getConnectors) {
     }
     return keep;
 }
+/**
+ * The host that grants `target` the spotlight, or `null` when none does.
+ *
+ * A host qualifies when its type was REGISTERED as a spotlight host
+ * (`SpotlightHostExtension`), when it did not opt out (`spotlightEnabled:
+ * false`, its toolbar toggle) and when its bounds contain the target. A
+ * background whose type is not registered grants nothing, whatever fields it
+ * carries — that is how the EDGY facets Venn stopped spotlighting (#195).
+ *
+ * Pure — exported for unit tests.
+ */
+export function findSpotlightHost(target, elements, hostTypes) {
+    return (elements.find(el => hostTypes.includes(el.type) &&
+        el.spotlightEnabled !== false &&
+        el.elementBound.contains(target.elementBound)) ?? null);
+}
 /** Delay before a new spotlight is applied / cleared, so brushing across
  * elements doesn't flash the fade on and off. */
 const SPOTLIGHT_DELAY_MS = 140;
@@ -120,9 +136,7 @@ export class SpotlightManager extends InteractivityExtension {
         // The behavior is granted by a host whose bounds contain the target —
         // unless that host opted out (`spotlightEnabled: false`, toolbar toggle).
         const host = target
-            ? surface.elementModels.find(el => hostTypes.includes(el.type) &&
-                el.spotlightEnabled !== false &&
-                el.elementBound.contains(target.elementBound))
+            ? findSpotlightHost(target, surface.elementModels, hostTypes)
             : null;
         if (!target || !host) {
             // Debounced restore: brushing across the gaps between elements must not

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

@@ -0,0 +1,107 @@
+import type { InterchangeImportContext, InterchangeImportResult } from './interchange.js';
+/**
+ * **SVG → a canvas sketch.** The platform's VISUAL-tier importer, shared by
+ * every framework that declares it (`docs/adr/0012`, P2).
+ *
+ * ## The heuristics statement, and its known failure modes
+ *
+ * _This paragraph is ADR 0012's open question 2 — "each visual capability owes
+ * a one-paragraph statement of its heuristics and its known failure modes" —
+ * answered ONCE, here, because every framework that declares `…:svg:import`
+ * wraps this one function and therefore owes the same statement. It is
+ * referenced by `bpmn:svg:import` and by `wardley:svg:import`; a framework that
+ * ever wants a narrower or wider guess writes its own parser and its own
+ * paragraph beside it._
+ *
+ * **What it guesses.** An SVG carries a rendering, not a model, so this reader
+ * recognises GEOMETRY and nothing else: `<rect>` becomes a rectangle,
+ * `<circle>` and `<ellipse>` an ellipse, `<polygon>` a polygon, `<line>`,
+ * `<polyline>` and `<path>` a brush stroke sampled at its vertices, and
+ * `<text>` an editable free-text element. Fill, stroke, stroke width, font size
+ * and text anchor are carried across where the shape model has a direct
+ * equivalent, with CSS inheritance down `<g>` honoured and colours passed
+ * through verbatim. Coordinates are user units placed by the outermost
+ * viewport: the `viewBox` origin is subtracted and the `viewBox`-to-`width`
+ * scale is applied uniformly (`min(width / viewBox width, height / viewBox
+ * height)`, which is what the default `preserveAspectRatio` means), then every
+ * `translate(…)` on the way down. Everything it emits is an ADR 0007 **level 1**
+ * element — a plain shape on the free surface, which the author then PROMOTES.
+ * It recognises no role, no relation and no framework vocabulary, and it never
+ * claims to: a Wardley component and a text box are both `<rect>` plus
+ * `<text>`, and deciding which is which is the one question only the author can
+ * answer.
+ *
+ * **Where it is known to be wrong, and the list is meant to be complete.** A
+ * `scale`, `rotate`, `matrix` or `skew` transform is IGNORED rather than
+ * applied, so anything under one lands at its untransformed position and size.
+ * Curves (`C`, `S`, `Q`, `T`, `A`) are flattened to their endpoints, so a
+ * rounded connector arrives as a polyline through its anchor points and an arc
+ * that doubles back arrives as a straight line. A `<path>` that outlines a
+ * filled region (an arrowhead, an icon glyph) arrives as an open stroke, not as
+ * a filled shape. `<image>`, `<defs>`, `<marker>`, gradients, filters,
+ * `<clipPath>` and `<mask>` are skipped by the reader, and `<use>` and
+ * `<foreignObject>` never reach it at all — the SANITIZER removes them, because
+ * they are two of the constructs an SVG can carry code in. A `<style>` sheet is
+ * skipped, and that one is worth naming twice: mermaid paints almost entirely
+ * through CSS classes, so a mermaid SVG arrives in the initial colours — mostly
+ * black — with only the note to say why. `<title>`, `<desc>` and `<metadata>`
+ * are dropped in silence, deliberately and as the only exception to the rule
+ * below: they render nothing, so there is nothing to have lost.
+ *
+ * **What this reader alters without a note, because a note could not help.**
+ * Text width and height are ESTIMATED from the font size and the character
+ * count, because measuring text needs a font a pure function of a string is not
+ * allowed to have, so a label box is approximately and not exactly the size it
+ * was. Whitespace inside a label is collapsed to single spaces and trimmed
+ * (`xml:space="preserve"` is not honoured). A `<tspan>`'s own `x`/`y`, its `dx`
+ * / `dy` offsets and `dominant-baseline` are ignored, so a label laid out span
+ * by span arrives as plain stacked lines in document order. `stroke-dasharray`
+ * is not read, so a dashed line arrives solid. `em` font sizes are resolved
+ * against the inherited size only, with no font-relative refinement.
+ *
+ * **Everything else is reported.** Every OTHER construct this reader ignores,
+ * alters or cannot resolve produces exactly one `warning` note per KIND — never
+ * one per instance — so a result that looks empty always says why.
+ *
+ * ## What it never does
+ *
+ * **It writes no `interchange` payload, on any element, ever** — P2's hard
+ * rule, pinned by an anti-decay test in this package's own spec. There is
+ * nothing to preserve that the elements do not already carry: an SVG round-trip
+ * would be a re-render rather than a round-trip, and a payload would advertise
+ * a promise this tier deliberately does not make. `carried` and `quarantined`
+ * are therefore `0` in every report it returns, and the surface that offers the
+ * import must say all of this BEFORE the file is read.
+ *
+ * ## Pure, and framework-agnostic
+ *
+ * Text in, serialized element props out (P3): no `std`, no surface, no DI, so
+ * labre-mcp calls the very same function the editor commands call. It produces
+ * only generic `shape` / `text` / `brush` props and knows the name of no
+ * framework — which is exactly why several frameworks can declare it. ADR 0012
+ * explicitly rejects inferring one framework from a `.svg`, so the capability
+ * is declared per framework and this parser is what each of them wraps.
+ */
+/**
+ * The format id. Never used as a payload key, unlike every semantic format's —
+ * a visual import writes no payload at all — but it is what the report's
+ * headline calls itself ("SVG imported"), and what the registry's triple is
+ * built from.
+ */
+export declare const SVG_SKETCH_FORMAT_ID = "svg";
+export declare const SVG_SKETCH_EXTENSION = ".svg";
+export declare const SVG_SKETCH_MIME = "image/svg+xml";
+/**
+ * An SVG file as a canvas sketch — the shared VISUAL-tier importer.
+ *
+ * See this module's own documentation for the heuristics statement and the
+ * known failure modes (ADR 0012, open question 2). The contract in one
+ * sentence: the picture arrives as editable elements, and nothing else is
+ * promised.
+ *
+ * A blank or unrecognisable drawing is `0` elements and a note, NOT an
+ * exception: the file was read, it simply held nothing this reader draws, and a
+ * throw would show the user an error toast where the truth is a remark.
+ * Malformed XML is the exception, because then the file was not read at all.
+ */
+export declare function parseSvgSketch(source: string, context?: InterchangeImportContext): InterchangeImportResult;