@formicoidea/labre-framework-edgy 0.32.0 → 0.34.1

package/dist/toolbar/icons.js

@@ -44,6 +44,19 @@ export const edgyOutcomeIcon = svg `<svg width="24" height="24" viewBox="0 0 24
 export const edgyObjectIcon = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
   <rect x="3.5" y="6.5" width="17" height="11" stroke="currentColor" stroke-width="1.6"/>
 </svg>`;
+/**
+ * Relation — a bare line between two ends, with the label riding on it.
+ *
+ * No arrowhead, exactly like the 24 relations of the metamodel template: EDGY
+ * draws its links as plain lines and lets the verb say which way the sentence
+ * runs. The little box in the middle IS the verb the tool writes there.
+ */
+export const edgyRelationIcon = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M3.5 12 H20.5" stroke="currentColor" stroke-width="1.6"/>
+  <circle cx="3.8" cy="12" r="1.6" fill="currentColor"/>
+  <circle cx="20.2" cy="12" r="1.6" fill="currentColor"/>
+  <rect x="8" y="8.6" width="8" height="6.8" rx="1.4" fill="var(--affine-background-primary-color, #fff)" stroke="currentColor" stroke-width="1.4"/>
+</svg>`;
 /** Activity — right-pointing chevron. */
 export const edgyActivityIcon = svg `<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
   <path d="M3.5 6.5 H15 L20.5 12 L15 17.5 H3.5 Z" stroke="currentColor" stroke-width="1.6" stroke-linejoin="round"/>

package/dist/toolbar/senior-tool.js

@@ -3,6 +3,7 @@ import { html } from 'lit';
 export const edgySeniorTool = SeniorToolExtension('edgy', ({ block }) => {
     return {
         name: 'EDGY',
+        labelKey: 'com.labre.framework.edgy',
         content: html `<edgeless-edgy-senior-button
       .edgeless=${block}
     ></edgeless-edgy-senior-button>`,

package/dist/translations.d.ts

@@ -1,14 +1,24 @@
 import { type TranslationKeyManifestEntry } from '@formicoidea/labre-core/std';
 /**
- * THIS framework's contribution to the translation-key manifest.
+ * THIS framework's contribution to the translation-key manifest — every
+ * `com.labre.*` key EDGY can hand to `TranslationProvider.t`, derived from the
+ * very declarations the editor registers.
  *
  * Its command labels and descriptions are built from a TEMPLATE, so the
- * concrete keys exist nowhere but in the declarations themselves and the
- * core manifest could not restate them even if it wanted to. The
- * contribution therefore ships WITH the framework: in the bundled
+ * concrete keys exist nowhere but in the declarations themselves and the core
+ * manifest could not restate them even if it wanted to. The same now holds for
+ * the roles: one key per canonical verb, derived from the metamodel, so a
+ * relation added there contributes its keys without anybody editing this file.
+ *
+ * That derivation is why the hand-drawn relation tool needed no line here: its
+ * `com.labre.commands.edgy.addRelation` and the `.description` key that carries
+ * its gesture sentence — the first DESCRIPTION any EDGY command has declared —
+ * are collected off `edgyCommands` with their English fallbacks, like every
+ * label before them.
+ *
+ * The contribution therefore ships WITH the framework: in the bundled
  * distribution `@formicoidea/labre-framework-edgy` carries it, and a host
- * composes it into its catalogue exactly as it already composes
- * `edgyCommands` into the command registry. See
- * `packages/affine/all/src/translations.ts`.
+ * composes it into its catalogue exactly as it already composes `edgyCommands`
+ * into the command registry. See `packages/affine/all/src/translations.ts`.
  */
 export declare const edgyTranslationEntries: TranslationKeyManifestEntry[];

package/dist/translations.js

@@ -1,15 +1,44 @@
-import { commandTranslationEntries, } from '@formicoidea/labre-core/std';
+import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
 import { edgyCommands } from './commands.js';
+import { NODE_LABEL, nodeLabelKey } from './node/consts.js';
+import { EDGY_NUDGES } from './nudges.js';
+import { EDGY_PROFILES } from './profiles.js';
+import { EDGY_ROLES } from './roles.js';
+import { EDGY_RULES } from './rules.js';
 /**
- * THIS framework's contribution to the translation-key manifest.
+ * THIS framework's contribution to the translation-key manifest — every
+ * `com.labre.*` key EDGY can hand to `TranslationProvider.t`, derived from the
+ * very declarations the editor registers.
  *
  * Its command labels and descriptions are built from a TEMPLATE, so the
- * concrete keys exist nowhere but in the declarations themselves and the
- * core manifest could not restate them even if it wanted to. The
- * contribution therefore ships WITH the framework: in the bundled
+ * concrete keys exist nowhere but in the declarations themselves and the core
+ * manifest could not restate them even if it wanted to. The same now holds for
+ * the roles: one key per canonical verb, derived from the metamodel, so a
+ * relation added there contributes its keys without anybody editing this file.
+ *
+ * That derivation is why the hand-drawn relation tool needed no line here: its
+ * `com.labre.commands.edgy.addRelation` and the `.description` key that carries
+ * its gesture sentence — the first DESCRIPTION any EDGY command has declared —
+ * are collected off `edgyCommands` with their English fallbacks, like every
+ * label before them.
+ *
+ * The contribution therefore ships WITH the framework: in the bundled
  * distribution `@formicoidea/labre-framework-edgy` carries it, and a host
- * composes it into its catalogue exactly as it already composes
- * `edgyCommands` into the command registry. See
- * `packages/affine/all/src/translations.ts`.
+ * composes it into its catalogue exactly as it already composes `edgyCommands`
+ * into the command registry. See `packages/affine/all/src/translations.ts`.
  */
-export const edgyTranslationEntries = commandTranslationEntries(edgyCommands);
+export const edgyTranslationEntries = mergeTranslationEntries(commandTranslationEntries(edgyCommands), 
+// The catalogue's own group headers, derived from the very categories
+// these commands declare. They ship WITH the framework because core's
+// registry names no framework category in the bundled distribution, so a
+// host that composed core's manifest alone drew translated entries under
+// English headers (#183).
+commandCategoryTranslationEntries(edgyCommands), collectTranslationKeys('role', EDGY_ROLES), collectTranslationKeys('rule', EDGY_RULES), collectTranslationKeys('nudge', EDGY_NUDGES), collectTranslationKeys('profile', EDGY_PROFILES), 
+// The captions a placed base element is seeded with. Derived from
+// `NODE_LABEL`, the very table the gesture writes from, so the wording a
+// host is offered is the wording the canvas would have carried.
+Object.entries(NODE_LABEL).map(([kind, label]) => ({
+    key: nodeLabelKey(kind),
+    fallback: label,
+    source: 'seed',
+})));

package/dist/view.d.ts

@@ -2,17 +2,20 @@ import { type ViewExtensionContext, ViewExtensionProvider } from '@formicoidea/l
 /**
  * EDGY rendering — ALWAYS registered, independent of any flag. Disabling `edgy`
  * hides only the creation tooling (see {@link EdgyViewExtension}); boards and
- * facets already drawn must still paint, stay selectable, stay editable, keep
- * their contextual toolbar and keep the dependency spotlight. See
- * `docs/adr/0009`.
+ * facets already drawn must still paint, stay selectable, stay editable and
+ * keep their contextual toolbar — and a board must keep the dependency
+ * spotlight it hosts. See `docs/adr/0009`.
  */
 export declare class EdgyRenderViewExtension extends ViewExtensionProvider {
     name: string;
     setup(context: ViewExtensionContext): void;
 }
 /**
- * EDGY creation tooling — flag-gated (`edgy`): the senior toolbar button and
- * its templates category.
+ * EDGY creation tooling — flag-gated (`edgy`): the senior toolbar button, its
+ * templates category, and the validation rules, profiles and quality checklist.
+ * All of it is tooling: a board drawn while the flag was on keeps rendering when
+ * it goes off, it just stops being checked — and the profile it was put on stays
+ * written, unread, until the flag comes back (`docs/adr/0009`).
  */
 export declare class EdgyViewExtension extends ViewExtensionProvider {
     name: string;

package/dist/view.js

@@ -1,9 +1,16 @@
-import { SpotlightHostExtension } from '@formicoidea/labre-core/blocks/surface';
+import { QualityNudgeExtension, SpotlightHostExtension, ValidationProfileExtension, ValidationRuleExtension, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
+import { ToolbarModuleExtension } from '@formicoidea/labre-core/shared/services';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { extendTemplateCategory } from '@formicoidea/labre-core/gfx/template';
-import { CommandExtension } from '@formicoidea/labre-core/std';
+import { BlockFlavourIdentifier, CommandExtension } from '@formicoidea/labre-core/std';
+import { RoleVocabularyExtension } from '@formicoidea/labre-core/std/gfx';
 import { edgyCommandIcons, edgyCommands } from './commands.js';
 import { effects } from './effects.js';
+import { EDGY_NUDGES } from './nudges.js';
+import { EDGY_PROFILES } from './profiles.js';
+import { EdgyRelationResolver } from './relation-resolver.js';
+import { EDGY_ROLES } from './roles.js';
+import { EDGY_RULES } from './rules.js';
 import { edgyTemplateCategory } from './templates/index.js';
 import { EdgyBoardRendererExtension } from './board-renderer.js';
 import { EdgyBoardInteraction, EdgyBoardView } from './board-view.js';
@@ -17,9 +24,9 @@ import { edgySeniorTool } from './toolbar/senior-tool.js';
 /**
  * EDGY rendering — ALWAYS registered, independent of any flag. Disabling `edgy`
  * hides only the creation tooling (see {@link EdgyViewExtension}); boards and
- * facets already drawn must still paint, stay selectable, stay editable, keep
- * their contextual toolbar and keep the dependency spotlight. See
- * `docs/adr/0009`.
+ * facets already drawn must still paint, stay selectable, stay editable and
+ * keep their contextual toolbar — and a board must keep the dependency
+ * spotlight it hosts. See `docs/adr/0009`.
  */
 export class EdgyRenderViewExtension extends ViewExtensionProvider {
     constructor() {
@@ -34,21 +41,32 @@ export class EdgyRenderViewExtension extends ViewExtensionProvider {
         context.register(EdgyBoardRendererExtension);
         context.register(EdgyNodeView);
         context.register(EdgyNodeRendererExtension);
+        // The role VOCABULARY, always on. A role is written in the document, not in
+        // the tooling: the direction reveal of a typed relation, the inversion
+        // command and the toolbar entry that must not lie about one all read this,
+        // and they have to keep working on a board drawn while the flag was on and
+        // opened while it is off (`docs/adr/0009`, `docs/adr/0010`). The rules that
+        // JUDGE those roles stay in the flag-gated extension below.
+        context.register(RoleVocabularyExtension(EDGY_ROLES));
         if (this.isEdgeless(context.scope)) {
             context.register(EdgyInteraction);
             context.register(EdgyBoardInteraction);
             context.register(edgyToolbarExtension);
             context.register(edgyBoardToolbarExtension);
             context.register(edgyNodeToolbarExtension);
-            // Both EDGY backgrounds grant the dependency spotlight on hover.
-            context.register(SpotlightHostExtension('edgy'));
+            // The dependency spotlight on hover is BOARD logic: only the EDGY board
+            // grants it. The facets Venn is a drawing — it keeps its appearance
+            // toggles (labels, pictos, crop, resize) and nothing else (#195).
             context.register(SpotlightHostExtension('edgyBoard'));
         }
     }
 }
 /**
- * EDGY creation tooling — flag-gated (`edgy`): the senior toolbar button and
- * its templates category.
+ * EDGY creation tooling — flag-gated (`edgy`): the senior toolbar button, its
+ * templates category, and the validation rules, profiles and quality checklist.
+ * All of it is tooling: a board drawn while the flag was on keeps rendering when
+ * it goes off, it just stops being checked — and the profile it was put on stays
+ * written, unread, until the flag comes back (`docs/adr/0009`).
  */
 export class EdgyViewExtension extends ViewExtensionProvider {
     constructor() {
@@ -64,8 +82,40 @@ export class EdgyViewExtension extends ViewExtensionProvider {
     setup(context) {
         super.setup(context);
         if (this.isEdgeless(context.scope)) {
+            context.register(ValidationRuleExtension(EDGY_RULES));
+            context.register(ValidationProfileExtension(EDGY_PROFILES));
+            // Work quality (WS1): the four expectations no algorithm can decide —
+            // including the two the PO deliberately kept out of `rules.ts` on
+            // 26/08/2026 (see `./nudges.ts`).
+            context.register(QualityNudgeExtension(EDGY_NUDGES));
+            // The Validation dropdown on a selected background's contextual toolbar.
+            // A SECOND module on the same element, through the `custom:` flavour slot
+            // (the pattern `gfx/wardley` uses on its map): the rendering toolbars are
+            // registered always-on because a stored board must keep its toggles,
+            // while choosing how hard to check it is tooling and belongs here. The
+            // config itself names no framework — it reads roles and profiles — so
+            // BOTH EDGY frames register the very same object.
+            for (const flavour of [
+                'custom:affine:surface:edgy',
+                'custom:affine:surface:edgyBoard',
+            ]) {
+                context.register(ToolbarModuleExtension({
+                    id: BlockFlavourIdentifier(flavour),
+                    config: validationToolbarConfig,
+                }));
+            }
+            // The resolver that turns a hand-drawn `edgy:relation` into the verb the
+            // metamodel gives its two ends. It belongs HERE and not in the always-on
+            // extension above, and the test is the one `docs/adr/0009` asks: does it
+            // paint stored content, or does it author new content? It authors — it
+            // writes a role and a label into the document — and the only edges it
+            // ever sees are the ones the flag-gated tool below stamps. A board drawn
+            // while the flag was on keeps every verb it was given (the vocabulary and
+            // the renderers are always on); with the flag off nothing new is named
+            // because nothing new is being armed. See `./relation-resolver.ts`.
+            context.register(EdgyRelationResolver);
             context.register(edgySeniorTool);
-            // The seven EDGY commands: the sub-menu renders them, Settings ›
+            // The eight EDGY commands: the sub-menu renders them, Settings ›
             // Shortcuts finally lists them, and a host override on an id binds.
             context.register(CommandExtension(edgyCommands, edgyCommandIcons));
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-edgy",
   "description": "Labre edgy framework for @formicoidea/labre-core.",
-  "version": "0.32.0",
+  "version": "0.34.1",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -21,13 +21,20 @@
     "./descriptor": {
       "types": "./dist/descriptor.d.ts",
       "import": "./dist/descriptor.js"
+    },
+    "./commands-manifest": {
+      "types": "./dist/commands-manifest.d.ts",
+      "import": "./dist/commands-manifest.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.32.0",
-    "lit": "^3.2.0"
+    "@formicoidea/labre-core": "0.34.1",
+    "@formicoidea/labre-ddd-shared": "0.34.1",
+    "@preact/signals-core": "^1.8.0",
+    "lit": "^3.2.0",
+    "yjs": "^13.6.21"
   }
 }