@formicoidea/labre-framework-edgy 0.31.0 → 0.33.0

package/dist/legend.js

@@ -0,0 +1,109 @@
+import { roleLabel, } from '@formicoidea/labre-ddd-shared';
+import { EDGY_DYNAMIC_NODES, EDGY_ZONE_FILL, EDGY_ZONES, edgyElementLabel, } from './metamodel.js';
+import { NODE_FILL, NODE_STROKE } from './node/consts.js';
+import { EDGY_ROLE, EDGY_ROLES } from './roles.js';
+/**
+ * What an EDGY background's automatic legend can say — a TABLE, and nothing
+ * else: the scan, the placement and the box are `createAutoLegend`'s job, the
+ * same generic the three DDD backgrounds were given
+ * (`@labre/affine-gfx-ddd-shared`, `shared/legend-auto.ts`). EDGY takes a
+ * dependency on that package for the generic and the box prefab alone; moving
+ * them to a neutral home would be the tidier answer and is not worth the churn
+ * of this fix.
+ *
+ * Every row is DERIVED — from the metamodel (`./metamodel.ts`: which elements
+ * exist, which zone each belongs to, what colour that zone is drawn in) and
+ * from the role vocabulary's own labels (`./roles.ts`). Nothing here is
+ * restated: a thirteenth element added to the metamodel gets its legend row the
+ * same way it gets its role, with no edit to this file.
+ *
+ * ## The order
+ *
+ * By ZONE, and the order of the table carries it: the three facets first
+ * (Identity, Architecture, Experience), then the three intersections in one
+ * section, then the four base elements, then the relations — which is the
+ * reading order of {@link EDGY_ZONES} and, before it, of the Venn itself.
+ */
+/** One row per official element of `zone`, in the metamodel's own order. */
+function zoneEntries(zone) {
+    return Object.entries(EDGY_DYNAMIC_NODES)
+        .filter(([, node]) => node.zone === zone)
+        .map(([name]) => ({
+        role: EDGY_ROLE[name],
+        row: {
+            swatch: 'square',
+            // The zone's fill, which IS what the diagram paints the element with.
+            color: EDGY_ZONE_FILL[zone],
+            label: roleLabel(EDGY_ROLES, EDGY_ROLE[name]),
+        },
+    }));
+}
+const FACET_SECTIONS = EDGY_ZONES.filter(zone => zone.group === 'facet').map(zone => ({
+    title: edgyElementLabel(zone.id),
+    entries: zoneEntries(zone.id),
+}));
+/**
+ * The three intersection elements in ONE section: Organisation, Product and
+ * Brand are not three facets, they are the three lenses between them, and the
+ * diagram says so by drawing them in the overlaps. Each keeps its own colour.
+ */
+const INTERSECTIONS_SECTION = {
+    title: 'Intersections',
+    entries: EDGY_ZONES.filter(zone => zone.group === 'intersection').flatMap(zone => zoneEntries(zone.id)),
+};
+/**
+ * The four base elements, listed only when one is on the board BARE — an
+ * element the user dropped from the toolbox and left as a People, an Outcome,
+ * an Object or an Activity, without saying which of the twelve it is. White,
+ * because that is the fill the palette gives them (`node/consts.ts`).
+ *
+ * `exact` is what makes "bare" true. Detection is otherwise an ancestor walk,
+ * and the twelve official elements specialise these four — Content is an
+ * object, Story an activity — so an "Object" row would appear on a board
+ * carrying nothing but Contents, keyed to a white swatch that is drawn nowhere
+ * on it. The relation entry below keeps the walk, because there the parent row
+ * IS the fair summary: a board carrying `edgy:expresses` carries a relation.
+ */
+const BASE_SECTION = {
+    title: 'Base elements',
+    entries: ['people', 'outcome', 'object', 'activity'].map(kind => ({
+        role: EDGY_ROLE[kind],
+        exact: true,
+        row: {
+            swatch: 'square',
+            color: NODE_FILL,
+            label: roleLabel(EDGY_ROLES, EDGY_ROLE[kind]),
+        },
+    })),
+};
+/**
+ * ONE row for the whole relation family, keyed on the PARENT role: a board
+ * carrying "content expresses purpose" carries `edgy:expresses`, which is a
+ * relation, and that is all the legend has to say. Twenty-two rows naming the
+ * verbs would restate the metamodel rather than document the drawing — and the
+ * verb travels on the link itself, visible, where it belongs.
+ */
+const RELATIONS_SECTION = {
+    title: 'Relations',
+    entries: [
+        {
+            role: EDGY_ROLE.relation,
+            row: {
+                swatch: 'line',
+                // The stroke `activateEdgyRelation` arms the connector tool with.
+                color: NODE_STROKE,
+                label: roleLabel(EDGY_ROLES, EDGY_ROLE.relation),
+            },
+        },
+    ],
+};
+export const EDGY_AUTO_LEGEND = {
+    title: 'Legend',
+    roles: EDGY_ROLES,
+    sections: [
+        ...FACET_SECTIONS,
+        INTERSECTIONS_SECTION,
+        BASE_SECTION,
+        RELATIONS_SECTION,
+    ],
+};

package/dist/metamodel.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The EDGY metamodel, as DATA — the 12 official elements and the 24 canonical
+ * relations that link them.
+ *
+ * It used to live in `templates/index.ts`, where it was drawn. It moved here
+ * the day the roles started being DERIVED from it (`./roles.ts`): the template
+ * needs the vocabulary to stamp its elements, and the vocabulary needs the
+ * metamodel to know which verbs exist, so a single module holding both would be
+ * a cycle. Nothing was renamed — `templates/index.ts` re-exports both tables
+ * under the names they always had.
+ *
+ * This file is the ONE place the metamodel is written down. `roles.ts` derives
+ * an edge role per verb from it, `rules.ts` derives the sanctioned sentences of
+ * `edgy.non-canonical-link` from it, and the template draws it. Restating the
+ * matrix anywhere else would be inviting the three to disagree.
+ */
+/**
+ * Official pastel fills per zone (the `pictograms/Shape-*.svg` colors) — the
+ * colour an element of that zone is DRAWN with, on the diagram and therefore in
+ * the legend that documents it.
+ *
+ * Exported because the legend needs the same swatch the board uses: a swatch
+ * restated as a second literal would be a colour free to drift away from the
+ * one the eye sees.
+ */
+export declare const EDGY_ZONE_FILL: {
+    readonly identity: "#80ffb7";
+    readonly architecture: "#a6c0ff";
+    readonly experience: "#ff99bd";
+    readonly organisation: "#80eaff";
+    readonly brand: "#ffd580";
+    readonly product: "#e599ff";
+};
+/** One of the six regions of the Venn: three facets, three intersections. */
+export type EdgyZone = keyof typeof EDGY_ZONE_FILL;
+/**
+ * The six zones, in reading order — the three FACETS first, then the three
+ * INTERSECTIONS, each named by the pair of circles it is the lens of (the very
+ * pairs `element-renderer.ts` clips: A∩B, B∩C, A∩C).
+ *
+ * Written down as data because the split is otherwise readable only inside the
+ * renderer's paint calls, and the legend has to group the twelve elements by
+ * it. `group` is the only thing here a reader could not already derive from
+ * {@link EDGY_DYNAMIC_NODES}.
+ */
+export declare const EDGY_ZONES: readonly {
+    id: EdgyZone;
+    group: 'facet' | 'intersection';
+}[];
+/**
+ * The 24 canonical EDGY relations (source, target, verb, label position along
+ * the link) — exported for the unit tests. 7 per facet + 3 between the
+ * intersections. The optional 4th member mirrors the reference diagram's
+ * placements: verbs of intersection-outgoing links sit near the far element
+ * (`labelOffset.distance` ≈ .75), short peer links keep the middle.
+ *
+ * Read the way `docs/adr/0010` reads every typed edge: the SOURCE is the
+ * subject of the verb and the TARGET its object, so each row is one sentence a
+ * practitioner would say out loud — "content expresses purpose". That is what
+ * makes the row usable as an {@link EndpointTriplet} without a single
+ * coordinate taking part.
+ */
+export declare const EDGY_DYNAMIC_RELATIONS: [string, string, string, number?][];
+/**
+ * The 12 elements, centred coordinates in REFERENCE coords (the fixed space
+ * of consts.ts — the same space as `VENN`), laid out like the reference
+ * "elements & relations" diagram: aligned top row, Story/Capability flanks,
+ * Brand/Product astride the white centre, Task/Journey/Channel triangle.
+ * Exported (with `dynToModel`) for the containment test.
+ *
+ * `kind` is the OFFICIAL kind of each element — the base shape EDGY draws it
+ * with — and `roles.ts` reads it to give each of the twelve leaf roles its
+ * parent. Written once, here, rather than restated as a second table nobody
+ * would think to keep in step.
+ *
+ * `zone` is the region of the Venn the element belongs to, and it REPLACES the
+ * fill this table used to carry: the fill is `EDGY_ZONE_FILL[zone]` and nothing
+ * else, so an element cannot be filed under one facet and painted another's
+ * colour. The template reads it to draw, the legend reads it to group and to
+ * swatch.
+ */
+export type EdgyElementName = 'content' | 'purpose' | 'organisation' | 'process' | 'asset' | 'story' | 'capability' | 'brand' | 'product' | 'task' | 'journey' | 'channel';
+/**
+ * The metamodel's own wording for one of its lowercase names — one of the
+ * twelve elements, or one of the six zones. It is the name written on the
+ * diagram, so it is also what the vocabulary falls back to and what the legend
+ * prints as a row label or a section title. One expression, one wording.
+ */
+export declare const edgyElementLabel: (name: EdgyElementName | EdgyZone) => string;
+export declare const EDGY_DYNAMIC_NODES: Record<EdgyElementName, {
+    kind: 'outcome' | 'object' | 'activity';
+    cx: number;
+    cy: number;
+    w?: number;
+    zone: EdgyZone;
+}>;

package/dist/metamodel.js

@@ -0,0 +1,128 @@
+/**
+ * The EDGY metamodel, as DATA — the 12 official elements and the 24 canonical
+ * relations that link them.
+ *
+ * It used to live in `templates/index.ts`, where it was drawn. It moved here
+ * the day the roles started being DERIVED from it (`./roles.ts`): the template
+ * needs the vocabulary to stamp its elements, and the vocabulary needs the
+ * metamodel to know which verbs exist, so a single module holding both would be
+ * a cycle. Nothing was renamed — `templates/index.ts` re-exports both tables
+ * under the names they always had.
+ *
+ * This file is the ONE place the metamodel is written down. `roles.ts` derives
+ * an edge role per verb from it, `rules.ts` derives the sanctioned sentences of
+ * `edgy.non-canonical-link` from it, and the template draws it. Restating the
+ * matrix anywhere else would be inviting the three to disagree.
+ */
+/**
+ * Official pastel fills per zone (the `pictograms/Shape-*.svg` colors) — the
+ * colour an element of that zone is DRAWN with, on the diagram and therefore in
+ * the legend that documents it.
+ *
+ * Exported because the legend needs the same swatch the board uses: a swatch
+ * restated as a second literal would be a colour free to drift away from the
+ * one the eye sees.
+ */
+export const EDGY_ZONE_FILL = {
+    identity: '#80ffb7',
+    architecture: '#a6c0ff',
+    experience: '#ff99bd',
+    organisation: '#80eaff',
+    brand: '#ffd580',
+    product: '#e599ff',
+};
+/**
+ * The six zones, in reading order — the three FACETS first, then the three
+ * INTERSECTIONS, each named by the pair of circles it is the lens of (the very
+ * pairs `element-renderer.ts` clips: A∩B, B∩C, A∩C).
+ *
+ * Written down as data because the split is otherwise readable only inside the
+ * renderer's paint calls, and the legend has to group the twelve elements by
+ * it. `group` is the only thing here a reader could not already derive from
+ * {@link EDGY_DYNAMIC_NODES}.
+ */
+export const EDGY_ZONES = [
+    { id: 'identity', group: 'facet' },
+    { id: 'architecture', group: 'facet' },
+    { id: 'experience', group: 'facet' },
+    // Identity ∩ Architecture, Architecture ∩ Experience, Experience ∩ Identity.
+    { id: 'organisation', group: 'intersection' },
+    { id: 'product', group: 'intersection' },
+    { id: 'brand', group: 'intersection' },
+];
+/**
+ * The 24 canonical EDGY relations (source, target, verb, label position along
+ * the link) — exported for the unit tests. 7 per facet + 3 between the
+ * intersections. The optional 4th member mirrors the reference diagram's
+ * placements: verbs of intersection-outgoing links sit near the far element
+ * (`labelOffset.distance` ≈ .75), short peer links keep the middle.
+ *
+ * Read the way `docs/adr/0010` reads every typed edge: the SOURCE is the
+ * subject of the verb and the TARGET its object, so each row is one sentence a
+ * practitioner would say out loud — "content expresses purpose". That is what
+ * makes the row usable as an {@link EndpointTriplet} without a single
+ * coordinate taking part.
+ */
+export const EDGY_DYNAMIC_RELATIONS = [
+    // Identity
+    ['content', 'purpose', 'expresses'],
+    ['content', 'story', 'conveys', 0.75],
+    ['story', 'purpose', 'contextualises', 0.8],
+    ['organisation', 'purpose', 'pursues', 0.8],
+    ['organisation', 'story', 'authors', 0.6],
+    ['brand', 'purpose', 'represents', 0.8],
+    ['brand', 'story', 'evokes', 0.65],
+    // Architecture
+    ['organisation', 'process', 'performs', 0.8],
+    ['process', 'capability', 'realises', 0.75],
+    ['process', 'asset', 'requires'],
+    ['capability', 'asset', 'requires', 0.75],
+    ['organisation', 'capability', 'has', 0.6],
+    ['product', 'capability', 'requires', 0.75],
+    ['process', 'product', 'creates', 0.65],
+    // Experience
+    ['task', 'journey', 'is part of', 0.6],
+    ['task', 'channel', 'uses', 0.6],
+    ['journey', 'channel', 'traverses', 0.6],
+    ['product', 'task', 'serves', 0.9],
+    ['product', 'journey', 'features in', 0.8],
+    ['brand', 'task', 'supports', 0.8],
+    ['brand', 'journey', 'appears in', 0.9],
+    // Intersections
+    ['organisation', 'brand', 'builds', 0.85],
+    ['organisation', 'product', 'makes', 0.65],
+    ['product', 'brand', 'embodies', 0.8],
+];
+/**
+ * The metamodel's own wording for one of its lowercase names — one of the
+ * twelve elements, or one of the six zones. It is the name written on the
+ * diagram, so it is also what the vocabulary falls back to and what the legend
+ * prints as a row label or a section title. One expression, one wording.
+ */
+export const edgyElementLabel = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+export const EDGY_DYNAMIC_NODES = {
+    content: { kind: 'object', cx: 237.5, cy: 100, zone: 'identity' },
+    purpose: { kind: 'outcome', cx: 282.5, cy: 100, zone: 'identity' },
+    organisation: {
+        kind: 'object',
+        cx: 340,
+        cy: 100,
+        w: 175,
+        zone: 'organisation',
+    },
+    process: { kind: 'activity', cx: 397.5, cy: 100, zone: 'architecture' },
+    asset: { kind: 'object', cx: 442.5, cy: 100, zone: 'architecture' },
+    story: { kind: 'activity', cx: 255, cy: 152.5, zone: 'identity' },
+    capability: {
+        kind: 'outcome',
+        cx: 425,
+        cy: 152.5,
+        w: 150,
+        zone: 'architecture',
+    },
+    brand: { kind: 'object', cx: 280, cy: 195, zone: 'brand' },
+    product: { kind: 'object', cx: 400, cy: 195, zone: 'product' },
+    task: { kind: 'outcome', cx: 310, cy: 257.5, zone: 'experience' },
+    journey: { kind: 'activity', cx: 370, cy: 257.5, zone: 'experience' },
+    channel: { kind: 'object', cx: 340, cy: 297.5, zone: 'experience' },
+};

package/dist/nudges.d.ts

@@ -0,0 +1,26 @@
+import type { QualityNudge } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * EDGY **work quality** — the checklist (WS1).
+ *
+ * Level 1 is `./rules.ts`: deterministic, decidable, real time. This file is
+ * level 2, and the split is the whole point of the taxonomy — a rule only
+ * enters the deterministic engine if an algorithm can decide it on persisted
+ * data inside the ~16 ms budget. Everything else is a NUDGE: an expectation
+ * offered as a checklist, never evaluated, never blocking anything. Ticking is
+ * assuming.
+ *
+ * ## Why q1 and q2 are here and not in `rules.ts` (PO arbitration, 26/08/2026)
+ *
+ * They read like rules, and they are not. "Each intersection element is linked
+ * to both of its parent facets" would need the tool to know which circle an
+ * element belongs to — and nothing says so except where somebody dropped it,
+ * which is the layout answering a question about meaning. "Each element wears
+ * its facet's colour" would indict every board whose author uses their own
+ * palette, which is most of them after the first workshop. Both are judgements
+ * a modeller makes; the tool can put them on screen and cannot answer them.
+ *
+ * Registered from the flag-gated `EdgyViewExtension`, beside the rules and the
+ * profiles: a checklist is tooling. Switching the flag off takes it away and
+ * leaves the ticks written on the board, unread, until it comes back (PF7.10).
+ */
+export declare const EDGY_NUDGES: readonly QualityNudge[];

package/dist/nudges.js

@@ -0,0 +1,54 @@
+/**
+ * EDGY **work quality** — the checklist (WS1).
+ *
+ * Level 1 is `./rules.ts`: deterministic, decidable, real time. This file is
+ * level 2, and the split is the whole point of the taxonomy — a rule only
+ * enters the deterministic engine if an algorithm can decide it on persisted
+ * data inside the ~16 ms budget. Everything else is a NUDGE: an expectation
+ * offered as a checklist, never evaluated, never blocking anything. Ticking is
+ * assuming.
+ *
+ * ## Why q1 and q2 are here and not in `rules.ts` (PO arbitration, 26/08/2026)
+ *
+ * They read like rules, and they are not. "Each intersection element is linked
+ * to both of its parent facets" would need the tool to know which circle an
+ * element belongs to — and nothing says so except where somebody dropped it,
+ * which is the layout answering a question about meaning. "Each element wears
+ * its facet's colour" would indict every board whose author uses their own
+ * palette, which is most of them after the first workshop. Both are judgements
+ * a modeller makes; the tool can put them on screen and cannot answer them.
+ *
+ * Registered from the flag-gated `EdgyViewExtension`, beside the rules and the
+ * profiles: a checklist is tooling. Switching the flag off takes it away and
+ * leaves the ticks written on the board, unread, until it comes back (PF7.10).
+ */
+export const EDGY_NUDGES = [
+    {
+        id: 'edgy.q1-intersection-links',
+        framework: 'edgy',
+        labelKey: 'com.labre.edgy.quality.intersection-links',
+        fallback: 'Each intersection element is linked to both of its parent facets.',
+        order: 1,
+    },
+    {
+        id: 'edgy.q2-facet-colour',
+        framework: 'edgy',
+        labelKey: 'com.labre.edgy.quality.facet-colour',
+        fallback: "Each element wears its facet's colour.",
+        order: 2,
+    },
+    {
+        id: 'edgy.q3-readable-relations',
+        framework: 'edgy',
+        labelKey: 'com.labre.edgy.quality.readable-relations',
+        fallback: 'Relations read correctly (the source is the subject of the verb).',
+        order: 3,
+    },
+    {
+        id: 'edgy.q4-three-facets',
+        framework: 'edgy',
+        labelKey: 'com.labre.edgy.quality.three-facets',
+        fallback: 'All three facets have been explored.',
+        order: 4,
+    },
+];

package/dist/profiles.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationProfile } from '@formicoidea/labre-core/blocks/surface';
+export declare const EDGY_PROFILES: readonly ValidationProfile[];

package/dist/profiles.js

@@ -0,0 +1,66 @@
+/**
+ * EDGY validation profiles (WS1).
+ *
+ * DATA owned by the framework, like its rules and its roles: the engine knows
+ * how to APPLY a profile, never which ones EDGY has. Adding a level of
+ * requirement is adding an entry to this array.
+ *
+ * A profile is chosen per BACKGROUND, not per document (PF9.1) — a workshop
+ * scribble and a deliverable model coexist on the same canvas with different
+ * requirements, and the choice rides on the facets diagram or board itself.
+ *
+ * Registered from the flag-gated `EdgyViewExtension`, beside the rules:
+ * switching the EDGY flag off takes the choice away with the rest of the
+ * tooling, and a board already set to `strict` simply stops being checked until
+ * it comes back — the id stays written, untouched.
+ */
+/**
+ * Sketch: every rule demoted to `audit`, so findings still reach `violations$`
+ * — a host panel and a conformance report see them — and the canvas says
+ * nothing at all.
+ *
+ * The DEFAULT, and deliberately so (PRD principle 3). EDGY is a WORKSHOP
+ * notation: elements land on the diagram in the order people say them, half the
+ * relations point the wrong way for the ten minutes it takes to argue about
+ * them, and boxes pile up in a corner before anybody sorts them into facets. A
+ * tool warning about all of that in real time would be arguing with the
+ * workshop.
+ *
+ * Being the default also means it is the one profile that WRITES NOTHING: a
+ * board on `sketch` carries no profile key, so every EDGY diagram ever drawn is
+ * on it, with no migration and no backfill.
+ */
+const sketch = {
+    id: 'edgy.sketch',
+    framework: 'edgy',
+    labelKey: 'com.labre.edgy.profile.sketch',
+    fallback: 'Sketch',
+    isDefault: true,
+    rules: {
+        'edgy.non-canonical-link': 'audit',
+        'edgy.overlapping-artefacts': 'audit',
+    },
+};
+/**
+ * Strict: the deliverable level. Both rules bite, and both severities are
+ * spelled out here rather than left absent — PF9.4 wants the answer readable in
+ * one place, and a profile that says "warning" out loud cannot be misread as
+ * "whatever the rule happens to declare this quarter".
+ *
+ * `warning` and not `blocking-overridable` for E1, though a relation outside the
+ * metamodel is exactly the statement a strict EDGY model must not contain:
+ * nothing in this library implements a blocking level, so the value would claim
+ * an effect that does not exist. When the gesture refusal lands, this is a
+ * two-word change and this file is the only one that moves.
+ */
+const strict = {
+    id: 'edgy.strict',
+    framework: 'edgy',
+    labelKey: 'com.labre.edgy.profile.strict',
+    fallback: 'Strict',
+    rules: {
+        'edgy.non-canonical-link': 'warning',
+        'edgy.overlapping-artefacts': 'warning',
+    },
+};
+export const EDGY_PROFILES = [sketch, strict];

package/dist/relation-resolver.d.ts

@@ -0,0 +1,32 @@
+import { InteractivityExtension } from '@formicoidea/labre-core/std/gfx';
+/**
+ * Turns "a connector was drawn, or one of its ends just moved" into a naming.
+ *
+ * Registered from the FLAG-GATED `EdgyViewExtension`, not from the always-on
+ * render one, and the distinction is `docs/adr/0009`'s: this is a creation
+ * tool. It authors content — it writes a role and a label into the document —
+ * and it only ever fires on an edge the flag-gated toolbox itself stamped
+ * `edgy:relation`. A board drawn while the flag was on keeps every verb it was
+ * given, painted by the always-on renderer and read by the always-on
+ * vocabulary; with the flag off nothing new is named because nothing new is
+ * being armed. Registering it always-on would mean the library kept authoring
+ * EDGY content for a host that switched EDGY off.
+ *
+ * The subscription mechanics are `EstuarineGhostManager`'s, including the part
+ * that matters: the surface is a SIGNAL, null at mount and replaced when the
+ * surface block is.
+ */
+export declare class EdgyRelationResolver extends InteractivityExtension {
+    static key: string;
+    private _subscriptions;
+    private _disposeSurfaceEffect;
+    private _pending;
+    private _candidates;
+    mounted(): void;
+    unmounted(): void;
+    private _forget;
+    private _unsubscribe;
+    private _resubscribe;
+    private _schedule;
+    private _flush;
+}

package/dist/relation-resolver.js

@@ -0,0 +1,101 @@
+import { InteractivityExtension } from '@formicoidea/labre-core/std/gfx';
+import { effect } from '@preact/signals-core';
+import { EDGY_RELATION_DELAY_MS, resolveEdgyRelations } from './relation.js';
+/**
+ * Turns "a connector was drawn, or one of its ends just moved" into a naming.
+ *
+ * Registered from the FLAG-GATED `EdgyViewExtension`, not from the always-on
+ * render one, and the distinction is `docs/adr/0009`'s: this is a creation
+ * tool. It authors content — it writes a role and a label into the document —
+ * and it only ever fires on an edge the flag-gated toolbox itself stamped
+ * `edgy:relation`. A board drawn while the flag was on keeps every verb it was
+ * given, painted by the always-on renderer and read by the always-on
+ * vocabulary; with the flag off nothing new is named because nothing new is
+ * being armed. Registering it always-on would mean the library kept authoring
+ * EDGY content for a host that switched EDGY off.
+ *
+ * The subscription mechanics are `EstuarineGhostManager`'s, including the part
+ * that matters: the surface is a SIGNAL, null at mount and replaced when the
+ * surface block is.
+ */
+export class EdgyRelationResolver extends InteractivityExtension {
+    constructor() {
+        super(...arguments);
+        this._subscriptions = [];
+        this._disposeSurfaceEffect = null;
+        this._pending = null;
+        this._candidates = new Set();
+    }
+    static { this.key = 'edgy-relation-resolver'; }
+    mounted() {
+        this._disposeSurfaceEffect = effect(() => {
+            this._resubscribe(this.gfx.surface$.value);
+        });
+    }
+    unmounted() {
+        this._disposeSurfaceEffect?.();
+        this._disposeSurfaceEffect = null;
+        this._unsubscribe();
+        this._forget();
+        super.unmounted();
+    }
+    _forget() {
+        if (this._pending)
+            clearTimeout(this._pending);
+        this._pending = null;
+        this._candidates.clear();
+    }
+    _unsubscribe() {
+        for (const subscription of this._subscriptions)
+            subscription.unsubscribe();
+        this._subscriptions = [];
+    }
+    _resubscribe(surface) {
+        this._unsubscribe();
+        // Candidates queued against the previous surface are about elements this
+        // one has never heard of.
+        this._forget();
+        if (!surface)
+            return;
+        this._subscriptions.push(surface.elementAdded.subscribe(({ id, local }) => {
+            if (!local)
+                return;
+            this._schedule(id);
+        }));
+        this._subscriptions.push(surface.elementUpdated.subscribe(({ id, props, local }) => {
+            // LOCAL only, the filter `reading.ts` documents at length: `local`
+            // partitions the fleet into one writer and N−1 silent observers with
+            // no leader election. Without it, everyone on a shared board would
+            // name the same relation the moment it synced — the same role and the
+            // same word each time, so nothing would corrupt, but each peer would
+            // get an undo entry for a gesture they did not make.
+            if (!local)
+                return;
+            // Only the two ends can turn an unnamed relation into a sentence.
+            // Every other prop — a drag, a restyle, a label edit — must not even
+            // rearm the timer.
+            if (!props || (!('source' in props) && !('target' in props)))
+                return;
+            this._schedule(id);
+        }));
+    }
+    _schedule(id) {
+        this._candidates.add(id);
+        if (this._pending)
+            clearTimeout(this._pending);
+        this._pending = setTimeout(() => {
+            this._pending = null;
+            this._flush();
+        }, EDGY_RELATION_DELAY_MS);
+    }
+    _flush() {
+        const surface = this.gfx.surface;
+        const candidates = this._candidates;
+        // Whatever happens below, what accumulated is accounted for: a set left
+        // behind would be replayed against a later, unrelated gesture.
+        this._candidates = new Set();
+        if (!surface)
+            return;
+        resolveEdgyRelations(surface, candidates);
+    }
+}