@formicoidea/labre-framework-wardley 0.31.0 → 0.33.0

package/dist/index.d.ts

@@ -1 +1,27 @@
-export { wardleyShortcuts } from './shortcuts.js';
+export { WARDLEY_ROLE, WARDLEY_ROLES, type WardleyRole, type WardleyRoleId, } from './roles.js';
+export { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
+export { wardleyCommandIcons, wardleyCommands } from './commands.js';
+export { wardleyTranslationEntries } from './translations.js';
+export { WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+export { WARDLEY_PROFILES } from './profiles.js';
+export { WARDLEY_NUDGES } from './nudges.js';
+export { WARDLEY_NAMING_CONVENTIONS, WARDLEY_READING } from './reading.js';
+export { WARDLEY_RULES } from './rules.js';
+/**
+ * The map's own frame, declared. Public because a host that lays elements out
+ * against the plot — labre-mcp does, and so does anything that generates a map
+ * without an editor — needs the margins the renderer actually uses, and a
+ * second copy of four numbers is a copy that drifts (`templates/maps.ts` says
+ * how that went the first time). P3's packaging obligation: a value both
+ * consumers read is reachable from the index, never by deep import.
+ */
+export { WARDLEY_BACKGROUND } from './background.js';
+/**
+ * The OWM DSL, both directions — pure functions of text and models, exported
+ * for the reason ADR 0012 § P3 gives: the editor command and labre-mcp call the
+ * SAME function, and no serialization logic for a Labre framework lives outside
+ * this repo. `exportWardleyOwm` is what replaces labre-mcp's own serializer.
+ */
+export { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, type OwmPlot, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, type WardleyExportBoard, wardleyBoardFrom, wardleySafeFilename, } from './export.js';
+export { importWardleyOwm } from './import.js';
+export { WARDLEY_INTERCHANGE, WARDLEY_OWM_EXPORT, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange.js';

package/dist/index.js

@@ -1 +1,31 @@
-export { wardleyShortcuts } from './shortcuts.js';
+export { WARDLEY_ROLE, WARDLEY_ROLES, } from './roles.js';
+export { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
+export { wardleyCommandIcons, wardleyCommands } from './commands.js';
+export { wardleyTranslationEntries } from './translations.js';
+export { WARDLEY_NATURE, WARDLEY_NATURE_TAG_ID, WARDLEY_TAG_DEFS, } from './natures.js';
+export { WARDLEY_PROFILES } from './profiles.js';
+export { WARDLEY_NUDGES } from './nudges.js';
+export { WARDLEY_NAMING_CONVENTIONS, WARDLEY_READING } from './reading.js';
+export { WARDLEY_RULES } from './rules.js';
+/**
+ * The map's own frame, declared. Public because a host that lays elements out
+ * against the plot — labre-mcp does, and so does anything that generates a map
+ * without an editor — needs the margins the renderer actually uses, and a
+ * second copy of four numbers is a copy that drifts (`templates/maps.ts` says
+ * how that went the first time). P3's packaging obligation: a value both
+ * consumers read is reachable from the index, never by deep import.
+ */
+export { WARDLEY_BACKGROUND } from './background.js';
+/**
+ * The OWM DSL, both directions — pure functions of text and models, exported
+ * for the reason ADR 0012 § P3 gives: the editor command and labre-mcp call the
+ * SAME function, and no serialization logic for a Labre framework lives outside
+ * this repo. `exportWardleyOwm` is what replaces labre-mcp's own serializer.
+ */
+export { exportWardleyOwm, exportWardleyOwmWithWarnings, OWM_SCOPE, owmCoordsOf, owmPlotOf, owmPointOf, WARDLEY_OWM_FORMAT_ID, wardleyBoardFrom, wardleySafeFilename, } from './export.js';
+export { importWardleyOwm } from './import.js';
+// Wardley's entries in the interchange registry (`docs/adr/0012`) — the OWM
+// DSL both ways, and the visual-tier SVG fallback. Exported whole so a host can
+// ask what Wardley can read and write without mounting an editor, and call it
+// without one either (P3).
+export { WARDLEY_INTERCHANGE, WARDLEY_OWM_EXPORT, WARDLEY_OWM_EXTENSION, WARDLEY_OWM_FORMAT, WARDLEY_OWM_IMPORT, WARDLEY_OWM_MIME, WARDLEY_SVG_FORMAT, WARDLEY_SVG_IMPORT, } from './interchange.js';

package/dist/interchange.d.ts

@@ -0,0 +1,80 @@
+import type { InterchangeCapability, InterchangeExportCapability, InterchangeFormat, InterchangeImportCapability } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * Wardley's entries in the interchange registry (`docs/adr/0012`, P1).
+ *
+ * Two formats and three rows. Both directions of the OWM DSL — the export is
+ * the row the ADR records as **owed** (a Wardley serializer exists today in
+ * labre-mcp, outside this repo, and is the one violation of P3 the ADR names;
+ * it exists here now, so that repo becomes a caller and its copy is deleted),
+ * and the import is the row the ADR calls **the reference Wardley import**,
+ * because the OWM DSL is the settled Wardley vocabulary while mermaid's Wardley
+ * diagram type is still experimental upstream. Then SVG IN, the visual-tier
+ * FALLBACK, which promises recognition and nothing else.
+ *
+ * The file is laid out as one section per FORMAT, each holding its format
+ * object then its capabilities, with {@link WARDLEY_INTERCHANGE} at the bottom
+ * collecting them. A format is added by adding a section, not by editing one.
+ *
+ * Everything here is pure. No half has ever had a `std` in sight, and this file
+ * adds no editor to any of them: it picks the artefacts the writer speaks about
+ * out of a surface's elements, and hands a reader's output straight back.
+ */
+/**
+ * The OnlineWardleyMaps DSL. **Semantic** — the file carries a model, not a
+ * picture: a `[visibility, evolution]` pair IS a position on the value chain
+ * and on the evolution axis, so the whole preservation contract applies and the
+ * import needs no invented axis (P2, and D4's "a format that carries
+ * coordinates but no pixels").
+ *
+ * `text/plain`, because that is what a DSL is, and `.owm` first — it is the
+ * extension a download is given. `.wm` rides behind it: the same bytes are
+ * written under both in the wild, and a picker that refused one would refuse a
+ * valid map for the sake of a filename. What the file actually IS is decided by
+ * the reader.
+ *
+ * The two directions share the FORMAT object, deliberately. `owm` is the id
+ * under which foreign matter rides on an element (D2), so a reader and a writer
+ * that disagreed about it would write payloads the other could not find.
+ */
+export declare const WARDLEY_OWM_EXTENSION = ".owm";
+export declare const WARDLEY_OWM_MIME = "text/plain";
+export declare const WARDLEY_OWM_FORMAT: InterchangeFormat;
+/** `wardley:owm:export` — the row that replaces labre-mcp's own serializer. */
+export declare const WARDLEY_OWM_EXPORT: InterchangeExportCapability;
+/** `wardley:owm:import` — an `.owm` file as a map. */
+export declare const WARDLEY_OWM_IMPORT: InterchangeImportCapability;
+/**
+ * SVG. **Visual** — the file carries a rendering, not a model, so it makes
+ * exactly one promise: the picture arrives as editable elements.
+ *
+ * Wardley's own format object, and NOT one shared with BPMN's, because ADR 0012
+ * rejects "one capability per format, with the framework inferred from the
+ * file": a `.svg` is read by several frameworks, and deciding which one a
+ * picture is a picture OF is the guess this platform refuses everywhere else.
+ * The three constants are the parser package's, so the declarations cannot
+ * drift into filtering a picker on different extensions.
+ */
+export declare const WARDLEY_SVG_FORMAT: InterchangeFormat;
+/**
+ * `wardley:svg:import` — an SVG as a sketch, best effort.
+ *
+ * **The heuristics statement and the known failure modes this capability owes
+ * (ADR 0012, open question 2) are the module documentation of
+ * `packages/affine/blocks/surface/src/extensions/svg-sketch.ts`.** Written once
+ * there because Wardley and BPMN wrap the SAME parser and therefore make the
+ * same guesses — and because the ADR's question is about what a visual
+ * capability is ALLOWED to guess, which for both of them is: geometry, and
+ * nothing else. A circle is a circle; whether it is a component is the
+ * author's sentence, not this reader's.
+ *
+ * What lands is an ADR 0007 level-1 sketch — plain shapes, brush strokes and
+ * editable free text — which the author then PROMOTES onto a map. In
+ * particular the two axes and the evolution bands are NOT recovered: a map's
+ * coordinates are its meaning, and reading them off a picture would be
+ * inventing a position and presenting it as read. {@link WARDLEY_OWM_IMPORT}
+ * beside it is the route a user should be pointed at, exactly as P2 says —
+ * this one is for the picture somebody sent you from a tool that writes no OWM.
+ */
+export declare const WARDLEY_SVG_IMPORT: InterchangeImportCapability;
+/** Everything Wardley registers, in one list the view extension hands over. */
+export declare const WARDLEY_INTERCHANGE: readonly InterchangeCapability[];

package/dist/interchange.js

@@ -0,0 +1,138 @@
+import { interchangeCapabilityId, parseSvgSketch, SVG_SKETCH_EXTENSION, SVG_SKETCH_FORMAT_ID, SVG_SKETCH_MIME, } from '@formicoidea/labre-core/blocks/surface';
+import { exportWardleyOwmWithWarnings, WARDLEY_OWM_FORMAT_ID, wardleyBoardFrom, wardleySafeFilename, } from './export.js';
+import { importWardleyOwm } from './import.js';
+/**
+ * Wardley's entries in the interchange registry (`docs/adr/0012`, P1).
+ *
+ * Two formats and three rows. Both directions of the OWM DSL — the export is
+ * the row the ADR records as **owed** (a Wardley serializer exists today in
+ * labre-mcp, outside this repo, and is the one violation of P3 the ADR names;
+ * it exists here now, so that repo becomes a caller and its copy is deleted),
+ * and the import is the row the ADR calls **the reference Wardley import**,
+ * because the OWM DSL is the settled Wardley vocabulary while mermaid's Wardley
+ * diagram type is still experimental upstream. Then SVG IN, the visual-tier
+ * FALLBACK, which promises recognition and nothing else.
+ *
+ * The file is laid out as one section per FORMAT, each holding its format
+ * object then its capabilities, with {@link WARDLEY_INTERCHANGE} at the bottom
+ * collecting them. A format is added by adding a section, not by editing one.
+ *
+ * Everything here is pure. No half has ever had a `std` in sight, and this file
+ * adds no editor to any of them: it picks the artefacts the writer speaks about
+ * out of a surface's elements, and hands a reader's output straight back.
+ */
+/* ── OWM (semantic) ───────────────────────────────────────────────────── */
+/**
+ * The OnlineWardleyMaps DSL. **Semantic** — the file carries a model, not a
+ * picture: a `[visibility, evolution]` pair IS a position on the value chain
+ * and on the evolution axis, so the whole preservation contract applies and the
+ * import needs no invented axis (P2, and D4's "a format that carries
+ * coordinates but no pixels").
+ *
+ * `text/plain`, because that is what a DSL is, and `.owm` first — it is the
+ * extension a download is given. `.wm` rides behind it: the same bytes are
+ * written under both in the wild, and a picker that refused one would refuse a
+ * valid map for the sake of a filename. What the file actually IS is decided by
+ * the reader.
+ *
+ * The two directions share the FORMAT object, deliberately. `owm` is the id
+ * under which foreign matter rides on an element (D2), so a reader and a writer
+ * that disagreed about it would write payloads the other could not find.
+ */
+export const WARDLEY_OWM_EXTENSION = '.owm';
+export const WARDLEY_OWM_MIME = 'text/plain';
+export const WARDLEY_OWM_FORMAT = {
+    id: WARDLEY_OWM_FORMAT_ID,
+    tier: 'semantic',
+    extensions: [WARDLEY_OWM_EXTENSION, '.wm'],
+    mime: WARDLEY_OWM_MIME,
+};
+/**
+ * The board as an OWM document.
+ *
+ * A thin adapter and nothing else: it picks the Wardley artefacts out of the
+ * surface, names the file, and passes the writer's losses straight through.
+ * There is no second door — `wardley.exportOwm` calls THIS, so the command and
+ * the registry cannot produce different bytes, filenames or warnings.
+ *
+ * `warnings` is omitted rather than empty when the map came out whole, so a
+ * caller can ask `if (result.warnings)` and mean it.
+ */
+const runWardleyOwmExport = (elements, context) => {
+    const name = wardleySafeFilename(context.name);
+    const { text, warnings } = exportWardleyOwmWithWarnings(wardleyBoardFrom(elements), { name });
+    return {
+        text,
+        filename: `${name}${WARDLEY_OWM_EXTENSION}`,
+        mime: WARDLEY_OWM_MIME,
+        ...(warnings.length > 0 ? { warnings } : {}),
+    };
+};
+/** `wardley:owm:export` — the row that replaces labre-mcp's own serializer. */
+export const WARDLEY_OWM_EXPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_OWM_FORMAT.id, 'export'),
+    framework: 'wardley',
+    format: WARDLEY_OWM_FORMAT,
+    direction: 'export',
+    run: runWardleyOwmExport,
+};
+/** `wardley:owm:import` — an `.owm` file as a map. */
+export const WARDLEY_OWM_IMPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_OWM_FORMAT.id, 'import'),
+    framework: 'wardley',
+    format: WARDLEY_OWM_FORMAT,
+    direction: 'import',
+    run: importWardleyOwm,
+};
+/* ── SVG (visual) ─────────────────────────────────────────────────────── */
+/**
+ * SVG. **Visual** — the file carries a rendering, not a model, so it makes
+ * exactly one promise: the picture arrives as editable elements.
+ *
+ * Wardley's own format object, and NOT one shared with BPMN's, because ADR 0012
+ * rejects "one capability per format, with the framework inferred from the
+ * file": a `.svg` is read by several frameworks, and deciding which one a
+ * picture is a picture OF is the guess this platform refuses everywhere else.
+ * The three constants are the parser package's, so the declarations cannot
+ * drift into filtering a picker on different extensions.
+ */
+export const WARDLEY_SVG_FORMAT = {
+    id: SVG_SKETCH_FORMAT_ID,
+    tier: 'visual',
+    extensions: [SVG_SKETCH_EXTENSION],
+    mime: SVG_SKETCH_MIME,
+};
+/**
+ * `wardley:svg:import` — an SVG as a sketch, best effort.
+ *
+ * **The heuristics statement and the known failure modes this capability owes
+ * (ADR 0012, open question 2) are the module documentation of
+ * `packages/affine/blocks/surface/src/extensions/svg-sketch.ts`.** Written once
+ * there because Wardley and BPMN wrap the SAME parser and therefore make the
+ * same guesses — and because the ADR's question is about what a visual
+ * capability is ALLOWED to guess, which for both of them is: geometry, and
+ * nothing else. A circle is a circle; whether it is a component is the
+ * author's sentence, not this reader's.
+ *
+ * What lands is an ADR 0007 level-1 sketch — plain shapes, brush strokes and
+ * editable free text — which the author then PROMOTES onto a map. In
+ * particular the two axes and the evolution bands are NOT recovered: a map's
+ * coordinates are its meaning, and reading them off a picture would be
+ * inventing a position and presenting it as read. {@link WARDLEY_OWM_IMPORT}
+ * beside it is the route a user should be pointed at, exactly as P2 says —
+ * this one is for the picture somebody sent you from a tool that writes no OWM.
+ */
+export const WARDLEY_SVG_IMPORT = {
+    id: interchangeCapabilityId('wardley', WARDLEY_SVG_FORMAT.id, 'import'),
+    framework: 'wardley',
+    format: WARDLEY_SVG_FORMAT,
+    direction: 'import',
+    run: parseSvgSketch,
+};
+/* ── The list the view extension registers ────────────────────────────── */
+/** Everything Wardley registers, in one list the view extension hands over. */
+export const WARDLEY_INTERCHANGE = [
+    WARDLEY_OWM_EXPORT,
+    WARDLEY_OWM_IMPORT,
+    WARDLEY_SVG_IMPORT,
+];

package/dist/legend.js

@@ -110,6 +110,14 @@ export function createWardleyLegend(std, bg) {
         xywh: new Bound(x, y, w, h).serialize(),
     });
     // ── glyph builders (real, editable elements), centred on (cx, cy) ─────
+    //
+    // DELIBERATELY ROLE-LESS. These are real `wardleyNode` elements, but a
+    // legend documents the map — it is not part of it. Giving its glyphs
+    // `wardley:component` & co. would make every legend entry count as an
+    // artefact and skew any rule written against roles (a legend would add a
+    // phantom component, anchor, market…). Neutral is the semantics we want;
+    // `kind` still drives their rendering. Frozen by a test in
+    // `__tests__/roles.unit.spec.ts`.
     const ellipse = (kind, d, fill, sw, cx, cy) => surface.addElement({
         type: 'wardleyNode',
         kind,

package/dist/natures.d.ts

@@ -0,0 +1,50 @@
+import type { UniverseTagDefs } from '@formicoidea/labre-core/shared/services';
+/**
+ * The Wardley **nature** tag — the framework's type-3 contextual qualification
+ * (PRD level 3, ADR 0007).
+ *
+ * A component's nature answers "what KIND of thing is this?", which is a
+ * different question from its role ("what is it, on a map?") and from its
+ * position ("how evolved is it?"). Simon Wardley's four are activity, data,
+ * practice and knowledge, and mapping practitioners routinely draw all four on
+ * one map — the same circle, the same axes, four different things.
+ *
+ * ## Why this ships as DATA, on the host's own mechanism
+ *
+ * The library fixes the FORMAT of tag definitions; the application seeds them.
+ * Nothing here is privileged: this pack is registered through the same
+ * `UniverseTagDefsExtension` a host uses for its own taxonomy, and a client's
+ * private extension of Wardley — say a `criticality` tag — is a second pack
+ * with a different `packId` that merges with this one, with no library release.
+ * Shipping one real pack is what keeps that mechanism honest.
+ *
+ * ## Why it applies to `wardley:component` and not to `'*'`
+ *
+ * A nature qualifies a component. `market` and `ecosystem` specialise
+ * `wardley:component`, so they get it for free through `roleIsA` — that is the
+ * entire reason role hierarchy is data. The `anchor` (a user / need) is
+ * deliberately NOT a child of `component` and is deliberately NOT qualified
+ * here: a need has no nature, it has a demand. The map itself, the change
+ * arrow, the inertia bar and the labels are chrome or annotations and are not
+ * candidates either.
+ *
+ * ## Why `cardinality: 'single'`
+ *
+ * A component is one of the four, not several. Where practitioners disagree —
+ * "is a data pipeline data or an activity?" — the disagreement is the finding,
+ * and forcing one answer is what makes the finding visible. A multi-valued
+ * nature would let the ambiguity hide inside the element.
+ *
+ * Labels are English fallbacks: the host localizes them. The library never
+ * pretends a def's `label` is already translated for someone else's locale, and
+ * a pack shipped as a `.json` asset carries whatever the host put in it.
+ */
+export declare const WARDLEY_NATURE_TAG_ID = "wardley:nature";
+/** The four natures, as value ids. Ids are forever; a def is only deprecated. */
+export declare const WARDLEY_NATURE: {
+    readonly activity: "wardley:nature/activity";
+    readonly data: "wardley:nature/data";
+    readonly practice: "wardley:nature/practice";
+    readonly knowledge: "wardley:nature/knowledge";
+};
+export declare const WARDLEY_TAG_DEFS: UniverseTagDefs;

package/dist/natures.js

@@ -0,0 +1,93 @@
+import { WARDLEY_ROLE } from './roles.js';
+/**
+ * The Wardley **nature** tag — the framework's type-3 contextual qualification
+ * (PRD level 3, ADR 0007).
+ *
+ * A component's nature answers "what KIND of thing is this?", which is a
+ * different question from its role ("what is it, on a map?") and from its
+ * position ("how evolved is it?"). Simon Wardley's four are activity, data,
+ * practice and knowledge, and mapping practitioners routinely draw all four on
+ * one map — the same circle, the same axes, four different things.
+ *
+ * ## Why this ships as DATA, on the host's own mechanism
+ *
+ * The library fixes the FORMAT of tag definitions; the application seeds them.
+ * Nothing here is privileged: this pack is registered through the same
+ * `UniverseTagDefsExtension` a host uses for its own taxonomy, and a client's
+ * private extension of Wardley — say a `criticality` tag — is a second pack
+ * with a different `packId` that merges with this one, with no library release.
+ * Shipping one real pack is what keeps that mechanism honest.
+ *
+ * ## Why it applies to `wardley:component` and not to `'*'`
+ *
+ * A nature qualifies a component. `market` and `ecosystem` specialise
+ * `wardley:component`, so they get it for free through `roleIsA` — that is the
+ * entire reason role hierarchy is data. The `anchor` (a user / need) is
+ * deliberately NOT a child of `component` and is deliberately NOT qualified
+ * here: a need has no nature, it has a demand. The map itself, the change
+ * arrow, the inertia bar and the labels are chrome or annotations and are not
+ * candidates either.
+ *
+ * ## Why `cardinality: 'single'`
+ *
+ * A component is one of the four, not several. Where practitioners disagree —
+ * "is a data pipeline data or an activity?" — the disagreement is the finding,
+ * and forcing one answer is what makes the finding visible. A multi-valued
+ * nature would let the ambiguity hide inside the element.
+ *
+ * Labels are English fallbacks: the host localizes them. The library never
+ * pretends a def's `label` is already translated for someone else's locale, and
+ * a pack shipped as a `.json` asset carries whatever the host put in it.
+ */
+export const WARDLEY_NATURE_TAG_ID = 'wardley:nature';
+/** The four natures, as value ids. Ids are forever; a def is only deprecated. */
+export const WARDLEY_NATURE = {
+    activity: `${WARDLEY_NATURE_TAG_ID}/activity`,
+    data: `${WARDLEY_NATURE_TAG_ID}/data`,
+    practice: `${WARDLEY_NATURE_TAG_ID}/practice`,
+    knowledge: `${WARDLEY_NATURE_TAG_ID}/knowledge`,
+};
+export const WARDLEY_TAG_DEFS = {
+    formatVersion: 1,
+    // The id of this PACK, not of the framework: several packs may extend
+    // Wardley, and re-registering this one replaces it rather than duplicating
+    // it.
+    packId: 'wardley-core',
+    framework: 'wardley',
+    label: 'Wardley',
+    tags: [
+        {
+            id: WARDLEY_NATURE_TAG_ID,
+            label: 'Nature',
+            description: 'What kind of thing this component is: an activity, data, a practice or knowledge.',
+            cardinality: 'single',
+            appliesTo: [WARDLEY_ROLE.component],
+            // No `order`: it is the only tag this pack declares, and an absent order
+            // sorts by SEED order, which is what puts the library's pack ahead of a
+            // client's extension without either having to know about the other. A
+            // number here would be a claim about packs that do not exist yet.
+            values: [
+                {
+                    id: WARDLEY_NATURE.activity,
+                    label: 'Activity',
+                    description: 'Something that is DONE — a step, a service, a process.',
+                },
+                {
+                    id: WARDLEY_NATURE.data,
+                    label: 'Data',
+                    description: 'Something that is RECORDED — a dataset, a register.',
+                },
+                {
+                    id: WARDLEY_NATURE.practice,
+                    label: 'Practice',
+                    description: 'A way of doing — a method, a convention, an operating model.',
+                },
+                {
+                    id: WARDLEY_NATURE.knowledge,
+                    label: 'Knowledge',
+                    description: 'Something that is KNOWN — a model, a theory, a rule.',
+                },
+            ],
+        },
+    ],
+};

package/dist/node/node-renderer.js

@@ -1,6 +1,6 @@
 import { ElementRendererExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { shape as shapeRenderer } from '@formicoidea/labre-core/gfx/shape';
-import { DefaultTheme } from '@formicoidea/labre-core/model';
+import { DefaultTheme, } from '@formicoidea/labre-core/model';
 import { ANCHOR, ECOSYSTEM, METHOD, NODE_FILL } from './consts.js';
 /**
  * Renderer for a Wardley node. The circle is drawn by REUSING the native shape

package/dist/nudges.d.ts

@@ -0,0 +1,41 @@
+import type { QualityNudge } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * Wardley **map quality** — the checklist (PF13.9).
+ *
+ * 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.
+ *
+ * ## The check-up rules are gone (PO decision, 02/08/2026)
+ *
+ * Q5 (tone convention) and Q6 (phase nomenclature) used to live beside these,
+ * as on-demand rules behind a "Run check-up" button. The panel is now the
+ * checklist and nothing else: the PO's recette found that a second verdict, a
+ * button and a scope line asked the reader to hold three different kinds of
+ * statement in their head over a map that mostly wanted a title. Nothing was
+ * deleted from the platform — the on-demand MOMENT (PF5.14) and the
+ * `tone-convention` / `majority-fact` families are still in the engine, still
+ * tested, and the next framework that wants a check-up declares one. Wardley
+ * simply stopped exposing one.
+ *
+ * Registered from the flag-gated `WardleyViewExtension`, beside the rules and
+ * the profiles: a checklist is tooling. Switching the flag off takes it away and
+ * leaves the ticks written on the map, unread, until it comes back (PF7.10).
+ */
+/**
+ * **Q1–Q4** — the four things a Wardley map needs in order to do its job, and
+ * that no algorithm can check.
+ *
+ * Every one of them is about whether the map can be DISCUSSED. A map with no
+ * title is a diagram nobody can situate; one with no legend is a private
+ * notation; one whose evolution axis is drawn but not used is a value chain
+ * wearing a Wardley costume. The tool can put all four on screen and it cannot
+ * judge a single one — "the title contextualises the study" is a statement about
+ * meaning, and a rule claiming to have verified it would be lying.
+ *
+ * The wordings are the PO's own, from the review of 01/08/2026, carried as
+ * `fallback` so a host with no catalogue reads them exactly as written.
+ */
+export declare const WARDLEY_NUDGES: readonly QualityNudge[];

package/dist/nudges.js

@@ -0,0 +1,69 @@
+/**
+ * Wardley **map quality** — the checklist (PF13.9).
+ *
+ * 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.
+ *
+ * ## The check-up rules are gone (PO decision, 02/08/2026)
+ *
+ * Q5 (tone convention) and Q6 (phase nomenclature) used to live beside these,
+ * as on-demand rules behind a "Run check-up" button. The panel is now the
+ * checklist and nothing else: the PO's recette found that a second verdict, a
+ * button and a scope line asked the reader to hold three different kinds of
+ * statement in their head over a map that mostly wanted a title. Nothing was
+ * deleted from the platform — the on-demand MOMENT (PF5.14) and the
+ * `tone-convention` / `majority-fact` families are still in the engine, still
+ * tested, and the next framework that wants a check-up declares one. Wardley
+ * simply stopped exposing one.
+ *
+ * Registered from the flag-gated `WardleyViewExtension`, beside the rules and
+ * the profiles: a checklist is tooling. Switching the flag off takes it away and
+ * leaves the ticks written on the map, unread, until it comes back (PF7.10).
+ */
+/**
+ * **Q1–Q4** — the four things a Wardley map needs in order to do its job, and
+ * that no algorithm can check.
+ *
+ * Every one of them is about whether the map can be DISCUSSED. A map with no
+ * title is a diagram nobody can situate; one with no legend is a private
+ * notation; one whose evolution axis is drawn but not used is a value chain
+ * wearing a Wardley costume. The tool can put all four on screen and it cannot
+ * judge a single one — "the title contextualises the study" is a statement about
+ * meaning, and a rule claiming to have verified it would be lying.
+ *
+ * The wordings are the PO's own, from the review of 01/08/2026, carried as
+ * `fallback` so a host with no catalogue reads them exactly as written.
+ */
+export const WARDLEY_NUDGES = [
+    {
+        id: 'wardley.q1-title',
+        framework: 'wardley',
+        labelKey: 'com.labre.wardley.quality.title',
+        fallback: 'The map has a title that frames the study (scope, objective) and states what kind of map it is.',
+        order: 1,
+    },
+    {
+        id: 'wardley.q2-context',
+        framework: 'wardley',
+        labelKey: 'com.labre.wardley.quality.context',
+        fallback: 'The context of the map is stated.',
+        order: 2,
+    },
+    {
+        id: 'wardley.q3-legend',
+        framework: 'wardley',
+        labelKey: 'com.labre.wardley.quality.legend',
+        fallback: 'The map is legended.',
+        order: 3,
+    },
+    {
+        id: 'wardley.q4-evolution-axis',
+        framework: 'wardley',
+        labelKey: 'com.labre.wardley.quality.evolution-axis',
+        fallback: 'The evolution axis is used and legended.',
+        order: 4,
+    },
+];

package/dist/profiles.d.ts

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

package/dist/profiles.js

@@ -0,0 +1,87 @@
+/**
+ * Wardley validation profiles (PF9).
+ *
+ * DATA owned by the framework, like its rules, its roles and its background:
+ * the engine knows how to APPLY a profile, never which ones Wardley has. Adding
+ * a level of requirement is adding an entry to this array.
+ *
+ * A profile is chosen per MAP, not per document (PF9.1) — a rough sketch and a
+ * deliverable diagram coexist on the same canvas with different requirements,
+ * and the choice rides on the background element itself.
+ *
+ * Registered from the flag-gated `WardleyViewExtension`, beside the rules:
+ * switching the Wardley flag off takes the choice away with the rest of the
+ * tooling, and a map already set to `strict` simply stops being checked until
+ * it comes back — the id stays written, untouched.
+ */
+/**
+ * Learning: every rule is demoted to `audit`, so findings still reach
+ * `violations$` — a host panel and a conformance report see them — and the
+ * canvas says nothing at all. Nobody drawing gets interrupted.
+ *
+ * The DEFAULT, and deliberately so: the sketch wins (PRD principle 3). Somebody
+ * opening a Wardley map for the first time is exploring, not filing a
+ * deliverable, and the tool has no business telling them off for an arrow they
+ * have not finished turning round. Being the default also means it is the one
+ * profile that WRITES NOTHING: a map on `sketch` carries no profile key, so
+ * every map ever drawn is on it, with no migration and no backfill.
+ *
+ * Silencing ALL THREE is the architect's recommendation and is written here for
+ * the PO to confirm or overturn — it is one word per line either way.
+ */
+const sketch = {
+    id: 'wardley.sketch',
+    framework: 'wardley',
+    labelKey: 'com.labre.wardley.profile.sketch',
+    fallback: 'Sketch',
+    isDefault: true,
+    rules: {
+        'wardley.change-arrow-against-evolution': 'audit',
+        'wardley.inertia-off-transition': 'audit',
+        'wardley.overlapping-artefacts': 'audit',
+        // W4 too, and it is the one where the demotion matters most: a value chain
+        // is drawn before it is arranged, so half the links are momentarily
+        // upside-down while somebody thinks. The finding still reaches a host panel
+        // and a conformance report; the canvas says nothing.
+        'wardley.provider-above-consumer': 'audit',
+    },
+};
+/**
+ * Strict: the deliverable level. Every rule bites, and every severity a user
+ * gets is 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".
+ *
+ * ## Why W1 and W2 are not `blocking-overridable`
+ *
+ * They should be: pointing a change arrow backwards and parking an inertia bar
+ * in the middle of a phase are both statements that are simply false, and the
+ * architect's recommendation is that strict refuse the gesture and offer the
+ * way out.
+ *
+ * Nothing implements that yet. `blocking-overridable` is carried by the engine
+ * and read by nobody: no gesture is refused anywhere in this library. Declaring
+ * it here would be data claiming an effect that does not exist, and the honest
+ * move is a `warning` plus this paragraph. When the refusal lands, this is a
+ * two-word change and the profile is the only file that moves.
+ *
+ * W3 stays `warning` on its own merits: an overlap is a readability problem,
+ * and refusing a drag because two labels touch would be the tool fighting the
+ * hand.
+ */
+const strict = {
+    id: 'wardley.strict',
+    framework: 'wardley',
+    labelKey: 'com.labre.wardley.profile.strict',
+    fallback: 'Strict',
+    rules: {
+        'wardley.change-arrow-against-evolution': 'warning',
+        'wardley.inertia-off-transition': 'warning',
+        'wardley.overlapping-artefacts': 'warning',
+        // W4 is a `warning` for the same reason W1 and W2 are, plus one of its own:
+        // its two honest resolutions are a MOVE and a REVERSAL, and both are the
+        // user's call. A rule that refused the gesture would be picking one.
+        'wardley.provider-above-consumer': 'warning',
+    },
+};
+export const WARDLEY_PROFILES = [sketch, strict];