sysprom 1.17.0 → 1.18.0

package/dist/src/operations/graph-shared.js

@@ -0,0 +1,257 @@
+import { NODE_FILE_MAP } from "../schema.js";
+// ---------------------------------------------------------------------------
+// Mermaid ID sanitisation
+// ---------------------------------------------------------------------------
+/**
+ * Sanitise an identifier for use in Mermaid diagrams by replacing
+ * non-alphanumeric/underscore characters with an underscore.
+ * @param id - Identifier to sanitise
+ * @example
+ * // sanitiseMermaidId('I1:Name') // 'I1_Name'
+ */
+export function sanitiseMermaidId(id) {
+    return id.replace(/[^\w]/g, "_");
+}
+export const NODE_CATEGORIES = [
+    {
+        name: "intent",
+        label: "Intent",
+        types: NODE_FILE_MAP.INTENT,
+        colour: "#4A90D9",
+        textColour: "#fff",
+    },
+    {
+        name: "state",
+        label: "State",
+        types: NODE_FILE_MAP.STATE,
+        colour: "#67A86B",
+        textColour: "#fff",
+    },
+    {
+        name: "invariant",
+        label: "Invariants",
+        types: NODE_FILE_MAP.INVARIANTS,
+        colour: "#E8913A",
+        textColour: "#fff",
+    },
+    {
+        name: "decision",
+        label: "Decisions",
+        types: NODE_FILE_MAP.DECISIONS,
+        colour: "#9B59B6",
+        textColour: "#fff",
+    },
+    {
+        name: "change",
+        label: "Changes",
+        types: NODE_FILE_MAP.CHANGES,
+        colour: "#E74C3C",
+        textColour: "#fff",
+    },
+    {
+        name: "meta",
+        label: "Meta",
+        types: ["view", "milestone", "version"],
+        colour: "#95A5A6",
+        textColour: "#fff",
+    },
+];
+/**
+ * Return the category for a given node. Falls back to the last category
+ * if the node type is unknown.
+ * @param node - Node to obtain category for
+ * @example
+ * // categoryForNode(node).name
+ */
+export function categoryForNode(node) {
+    return (NODE_CATEGORIES.find((c) => c.types.includes(node.type)) ??
+        NODE_CATEGORIES[NODE_CATEGORIES.length - 1]);
+}
+/**
+ * Return the category for a node type.
+ * @param type - Node type string
+ * @example
+ * // categoryForType('intent').name // 'intent'
+ */
+export function categoryForType(type) {
+    return (NODE_CATEGORIES.find((c) => c.types.includes(type)) ??
+        NODE_CATEGORIES[NODE_CATEGORIES.length - 1]);
+}
+const NODE_TYPE_SHAPES = {
+    intent: "rounded",
+    concept: "rounded",
+    capability: "rounded",
+    element: "rectangle",
+    realisation: "rectangle",
+    invariant: "parallelogram",
+    principle: "parallelogram",
+    policy: "parallelogram",
+    protocol: "rectangle",
+    stage: "rectangle",
+    role: "rectangle",
+    gate: "rectangle",
+    mode: "rectangle",
+    artefact: "rectangle",
+    artefact_flow: "rectangle",
+    decision: "rhombus",
+    change: "rectangle",
+    view: "rectangle",
+    milestone: "rectangle",
+    version: "rectangle",
+};
+/**
+ * Map a node to its Mermaid shape.
+ * @param node - Node to determine shape for
+ * @example
+ */
+export function mermaidShapeForNode(node) {
+    return NODE_TYPE_SHAPES[node.type] ?? "rectangle";
+}
+/**
+ * Render a Mermaid node definition for a node id/name/shape.
+ * @param id - Node id
+ * @param name - Node name
+ * @param shape - Shape to render
+ * @param mode - Label mode, friendly shows id and name, compact shows id only
+ * @example
+ */
+export function renderMermaidNode(id, name, shape, mode = "friendly") {
+    const safeId = sanitiseMermaidId(id);
+    const label = mode === "compact" ? id : `${id}: ${name}`;
+    switch (shape) {
+        case "rounded":
+            return `${safeId}([${label}])`;
+        case "rhombus":
+            return `${safeId}{{${label}}}`;
+        case "parallelogram":
+            return `${safeId}[/${label}/]`;
+        case "rectangle":
+        default:
+            return `${safeId}[${label}]`;
+    }
+}
+/**
+ * Render a human-friendly relationship label including polarity and strength
+ * @param rel
+ * @example
+ */
+export function renderRelationshipLabel(rel) {
+    const parts = [];
+    if (rel.polarity)
+        parts.push(rel.polarity);
+    if (rel.strength !== undefined)
+        parts.push(rel.strength.toFixed(2));
+    if (parts.length === 0)
+        return rel.type;
+    return `${rel.type} (${parts.join(", ")})`;
+}
+// ---------------------------------------------------------------------------
+// Mermaid classDef generation
+// ---------------------------------------------------------------------------
+/**
+ * @example
+ */
+export function renderMermaidClassDefs() {
+    return NODE_CATEGORIES.map((c) => `classDef ${c.name} fill:${c.colour},color:${c.textColour}`);
+}
+/**
+ * @param node
+ * @example
+ */
+export function mermaidClassForNode(node) {
+    return categoryForNode(node).name;
+}
+// ---------------------------------------------------------------------------
+// DOT attribute helpers
+// ---------------------------------------------------------------------------
+/**
+ * @param node
+ * @example
+ */
+export function dotNodeAttrs(node) {
+    const cat = categoryForNode(node);
+    const shape = dotShapeForNode(node);
+    return `[label="${node.id}\\n${node.name}" shape=${shape} style=filled fillcolor="${cat.colour}" fontcolor="${cat.textColour}"]`;
+}
+/**
+ * Format a node label according to a mode. "friendly" shows id and name,
+ * "compact" shows only the id.
+ * @param node
+ * @param mode
+ * @example
+ */
+export function formatNodeLabel(node, mode) {
+    if (mode === "compact")
+        return node.id;
+    return `${node.id}: ${node.name}`;
+}
+// Backwards-compatible wrapper to allow optional labelMode parameter
+/**
+ * @param node
+ * @param mode
+ * @example
+ */
+export function dotNodeAttrsWithMode(node, mode = "friendly") {
+    const cat = categoryForNode(node);
+    const shape = dotShapeForNode(node);
+    const label = mode === "compact" ? node.id : `${node.id}\\n${node.name}`;
+    return `[label="${label}" shape=${shape} style=filled fillcolor="${cat.colour}" fontcolor="${cat.textColour}"]`;
+}
+function dotShapeForNode(node) {
+    const s = mermaidShapeForNode(node);
+    switch (s) {
+        case "rounded":
+            return "box";
+        case "rhombus":
+            return "diamond";
+        case "parallelogram":
+            return "parallelogram";
+        case "rectangle":
+        default:
+            return "box";
+    }
+}
+/**
+ * @param nodes
+ * @param opts
+ * @example
+ */
+export function filterNodes(nodes, opts) {
+    const { nodeTypes, nodeIds } = opts;
+    if (nodeTypes && nodeTypes.length > 0) {
+        nodes = nodes.filter((n) => nodeTypes.includes(n.type));
+    }
+    if (nodeIds && nodeIds.length > 0) {
+        nodes = nodes.filter((n) => nodeIds.includes(n.id));
+    }
+    return nodes;
+}
+/**
+ * @param rels
+ * @param opts
+ * @param allowedNodeIds
+ * @example
+ */
+export function filterRelationships(rels, opts, allowedNodeIds) {
+    const { relTypes } = opts;
+    if (relTypes && relTypes.length > 0) {
+        rels = rels.filter((r) => relTypes.includes(r.type));
+    }
+    if (allowedNodeIds) {
+        rels = rels.filter((r) => allowedNodeIds.has(r.from) && allowedNodeIds.has(r.to));
+    }
+    return rels;
+}
+/**
+ * @param nodes
+ * @param rels
+ * @example
+ */
+export function applyConnectedOnly(nodes, rels) {
+    const connectedIds = new Set();
+    for (const r of rels) {
+        connectedIds.add(r.from);
+        connectedIds.add(r.to);
+    }
+    return nodes.filter((n) => connectedIds.has(n.id));
+}

package/dist/src/operations/graph.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod";
-/** Generate a graph of a SysProM document in Mermaid or DOT format, with optional filtering by relationship type. */
+/** Generate a graph of a SysProM document in Mermaid or DOT format, with optional filtering. */
 export declare const graphOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
     doc: z.ZodObject<{
         $schema: z.ZodOptional<z.ZodString>;
@@ -185,8 +185,9 @@ export declare const graphOp: import("./define-operation.js").DefinedOperation<z
                 requires: "requires";
                 disables: "disables";
                 influence: "influence";
+                justifies: "justifies";
             }> & {
-                is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
             };
             description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
                 is(value: unknown): value is string | string[];
@@ -205,7 +206,7 @@ export declare const graphOp: import("./define-operation.js").DefinedOperation<z
                 [x: string]: unknown;
                 from: string;
                 to: string;
-                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
                 description?: string | string[] | undefined;
                 polarity?: "positive" | "negative" | "neutral" | "uncertain" | undefined;
                 strength?: number | undefined;
@@ -296,7 +297,7 @@ export declare const graphOp: import("./define-operation.js").DefinedOperation<z
                 [x: string]: unknown;
                 from: string;
                 to: string;
-                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
                 description?: string | string[] | undefined;
                 polarity?: "positive" | "negative" | "neutral" | "uncertain" | undefined;
                 strength?: number | undefined;
@@ -315,4 +316,19 @@ export declare const graphOp: import("./define-operation.js").DefinedOperation<z
         mermaid: "mermaid";
     }>>;
     typeFilter: z.ZodOptional<z.ZodString>;
+    nodeTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    relTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        TD: "TD";
+        BT: "BT";
+        RL: "RL";
+        LR: "LR";
+    }>>;
+    cluster: z.ZodDefault<z.ZodBoolean>;
+    labelMode: z.ZodDefault<z.ZodEnum<{
+        friendly: "friendly";
+        compact: "compact";
+    }>>;
+    connectedOnly: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodString>;

package/dist/src/operations/graph.js

@@ -1,72 +1,165 @@
 import * as z from "zod";
 import { defineOperation } from "./define-operation.js";
 import { SysProMDocument } from "../schema.js";
-function sanitiseMermaidId(id) {
-    return id.replace(/[^a-zA-Z0-9_]/g, "_");
-}
-function generateDot(doc, rels) {
+import { sanitiseMermaidId, NODE_CATEGORIES, mermaidShapeForNode, renderMermaidNode, renderMermaidClassDefs, mermaidClassForNode, dotNodeAttrsWithMode, filterNodes, filterRelationships, applyConnectedOnly, } from "./graph-shared.js";
+import { renderRelationshipLabel } from "./graph-shared.js";
+// ---------------------------------------------------------------------------
+// DOT generation
+// ---------------------------------------------------------------------------
+function generateDot(nodes, rels, cluster, layout, labelMode) {
     const lines = [];
     lines.push("digraph SysProM {");
-    lines.push("  rankdir=LR;");
-    // Add node labels
-    for (const node of doc.nodes) {
-        const label = `${node.id}\\n${node.name}`;
-        lines.push(`  "${node.id}" [label="${label}"];`);
+    // Map mermaid layout to DOT rankdir where needed
+    const rankdir = layout === "TD"
+        ? "TB"
+        : layout === "BT"
+            ? "BT"
+            : layout === "RL"
+                ? "RL"
+                : "LR";
+    lines.push(`  rankdir=${rankdir};`);
+    lines.push("  node [style=filled];");
+    if (cluster) {
+        for (const cat of NODE_CATEGORIES) {
+            const catNodes = nodes.filter((n) => cat.types.includes(n.type));
+            if (catNodes.length === 0)
+                continue;
+            lines.push(`  subgraph cluster_${cat.name} {`);
+            lines.push(`    label="${cat.label}";`);
+            lines.push(`    style=filled;`);
+            lines.push(`    color="${cat.colour}22";`);
+            for (const node of catNodes) {
+                lines.push(`    "${node.id}" ${dotNodeAttrsWithMode(node, labelMode)};`);
+            }
+            lines.push("  }");
+        }
+        const clusteredIds = new Set(NODE_CATEGORIES.flatMap((c) => nodes.filter((n) => c.types.includes(n.type)).map((n) => n.id)));
+        for (const node of nodes) {
+            if (!clusteredIds.has(node.id)) {
+                lines.push(`  "${node.id}" ${dotNodeAttrsWithMode(node, labelMode)};`);
+            }
+        }
+    }
+    else {
+        for (const node of nodes) {
+            lines.push(`  "${node.id}" ${dotNodeAttrsWithMode(node, labelMode)};`);
+        }
     }
-    // Add relationships
     for (const rel of rels ?? []) {
-        lines.push(`  "${rel.from}" -> "${rel.to}" [label="${rel.type}"];`);
+        const label = renderRelationshipLabel(rel);
+        const attrs = [`label="${label}"`];
+        if (rel.polarity === "negative")
+            attrs.push("style=dashed");
+        if (rel.strength !== undefined && rel.strength >= 0.8) {
+            attrs.push("penwidth=2");
+        }
+        lines.push(`  "${rel.from}" -> "${rel.to}" [${attrs.join(" ")}];`);
     }
     lines.push("}");
     return lines.join("\n");
 }
-function generateMermaid(doc, rels) {
+// ---------------------------------------------------------------------------
+// Mermaid generation
+// ---------------------------------------------------------------------------
+function generateMermaid(nodes, rels, cluster, layout, labelMode) {
     const lines = [];
-    lines.push("graph LR");
-    // Add node definitions with type-specific shapes
-    for (const node of doc.nodes) {
-        const id = sanitiseMermaidId(node.id);
-        let shape;
-        if (node.type === "decision") {
-            shape = `{${node.id}: ${node.name}}`;
+    lines.push(`graph ${layout}`);
+    for (const def of renderMermaidClassDefs()) {
+        lines.push(`  ${def}`);
+    }
+    lines.push("");
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    if (cluster) {
+        for (const cat of NODE_CATEGORIES) {
+            const catNodes = nodes.filter((n) => cat.types.includes(n.type));
+            if (catNodes.length === 0)
+                continue;
+            lines.push(`  subgraph ${cat.name} ["${cat.label}"]`);
+            for (const node of catNodes) {
+                const shape = mermaidShapeForNode(node);
+                const cls = mermaidClassForNode(node);
+                lines.push(`    ${renderMermaidNode(node.id, node.name, shape, labelMode)}:::${cls}`);
+            }
+            lines.push("  end");
+            lines.push("");
         }
-        else if (node.type === "invariant") {
-            shape = `[/${node.id}: ${node.name}/]`;
+        const categorizedTypes = new Set(NODE_CATEGORIES.flatMap((c) => c.types));
+        for (const node of nodes) {
+            if (categorizedTypes.has(node.type))
+                continue;
+            const shape = mermaidShapeForNode(node);
+            const cls = mermaidClassForNode(node);
+            lines.push(`  ${renderMermaidNode(node.id, node.name, shape, labelMode)}:::${cls}`);
         }
-        else {
-            shape = `[${node.id}: ${node.name}]`;
+    }
+    else {
+        for (const node of nodes) {
+            const shape = mermaidShapeForNode(node);
+            const cls = mermaidClassForNode(node);
+            lines.push(`  ${renderMermaidNode(node.id, node.name, shape, labelMode)}:::${cls}`);
         }
-        lines.push(`  ${id}${shape}`);
     }
-    // Add relationships
+    lines.push("");
     for (const rel of rels ?? []) {
+        if (!nodeIds.has(rel.from) || !nodeIds.has(rel.to))
+            continue;
         const fromId = sanitiseMermaidId(rel.from);
         const toId = sanitiseMermaidId(rel.to);
-        lines.push(`  ${fromId} -->|${rel.type}| ${toId}`);
+        const label = renderRelationshipLabel(rel);
+        let edge = `${fromId} -->|${label}| ${toId}`;
+        if (rel.polarity === "negative") {
+            edge = `${fromId} -.->|${label}| ${toId}`;
+        }
+        lines.push(`  ${edge}`);
     }
     return lines.join("\n");
 }
-function generateGraph(doc, format, typeFilter) {
-    let rels = doc.relationships ?? [];
-    if (typeFilter) {
-        rels = rels.filter((r) => r.type === typeFilter);
+// ---------------------------------------------------------------------------
+// Graph generation
+// ---------------------------------------------------------------------------
+function generateGraph(doc, format, filterOpts, layout, cluster, labelMode) {
+    let nodes = filterNodes(doc.nodes, filterOpts);
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    let rels = filterRelationships(doc.relationships ?? [], filterOpts, nodeIds);
+    if (filterOpts.connectedOnly) {
+        nodes = applyConnectedOnly(nodes, rels);
+        rels = filterRelationships(rels, {}, new Set(nodes.map((n) => n.id)));
     }
     if (format === "dot") {
-        return generateDot(doc, rels);
+        // Historically DOT output used left-right rankdir by default regardless
+        // of the Mermaid default layout. Preserve that behaviour: if the
+        // requested layout is the Mermaid default "TD", map it to "LR" for DOT
+        // so existing tests and callers keep expecting LR unless another layout
+        // was explicitly chosen.
+        const dotLayout = layout === "TD" ? "LR" : layout;
+        return generateDot(nodes, rels, cluster, dotLayout, labelMode);
     }
-    return generateMermaid(doc, rels);
+    return generateMermaid(nodes, rels, cluster, layout, labelMode);
 }
-/** Generate a graph of a SysProM document in Mermaid or DOT format, with optional filtering by relationship type. */
+/** Generate a graph of a SysProM document in Mermaid or DOT format, with optional filtering. */
 export const graphOp = defineOperation({
     name: "graph",
-    description: "Generate a graph of the SysProM document in Mermaid or DOT format, with optional filtering by relationship type.",
+    description: "Generate a graph of the SysProM document in Mermaid or DOT format, with optional filtering by node type, node ID, or relationship type.",
     input: z.object({
         doc: SysProMDocument,
         format: z.enum(["mermaid", "dot"]).default("mermaid"),
         typeFilter: z.string().optional(),
+        nodeTypes: z.array(z.string()).optional(),
+        nodeIds: z.array(z.string()).optional(),
+        relTypes: z.array(z.string()).optional(),
+        layout: z.enum(["LR", "TD", "RL", "BT"]).default("TD"),
+        cluster: z.boolean().default(true),
+        labelMode: z.enum(["friendly", "compact"]).default("friendly"),
+        connectedOnly: z.boolean().default(false),
     }),
     output: z.string(),
-    fn({ doc, format, typeFilter }) {
-        return generateGraph(doc, format, typeFilter);
+    fn({ doc, format, typeFilter, nodeTypes, nodeIds, relTypes, layout, cluster, labelMode, connectedOnly, }) {
+        const filterOpts = {
+            nodeTypes,
+            nodeIds,
+            relTypes: relTypes ?? (typeFilter ? [typeFilter] : undefined),
+            connectedOnly,
+        };
+        return generateGraph(doc, format, filterOpts, layout, cluster, labelMode);
     },
 });

package/dist/src/operations/index.d.ts

@@ -29,6 +29,9 @@ export { statsOp, type DocumentStats } from "./stats.js";
 export { searchOp } from "./search.js";
 export { checkOp } from "./check.js";
 export { graphOp } from "./graph.js";
+export { graphRefinementOp } from "./graph-refinement.js";
+export { graphDecisionOp } from "./graph-decision.js";
+export { graphDependencyOp } from "./graph-dependency.js";
 export { renameOp } from "./rename.js";
 export { jsonToMarkdownOp } from "./json-to-markdown.js";
 export { markdownToJsonOp } from "./markdown-to-json.js";

package/dist/src/operations/index.js

@@ -34,6 +34,9 @@ export { statsOp } from "./stats.js";
 export { searchOp } from "./search.js";
 export { checkOp } from "./check.js";
 export { graphOp } from "./graph.js";
+export { graphRefinementOp } from "./graph-refinement.js";
+export { graphDecisionOp } from "./graph-decision.js";
+export { graphDependencyOp } from "./graph-dependency.js";
 export { renameOp } from "./rename.js";
 // Conversion operations
 export { jsonToMarkdownOp } from "./json-to-markdown.js";

package/dist/src/operations/infer-completeness.d.ts

@@ -265,8 +265,9 @@ export declare const inferCompletenessOp: import("./define-operation.js").Define
                 requires: "requires";
                 disables: "disables";
                 influence: "influence";
+                justifies: "justifies";
             }> & {
-                is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
             };
             description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
                 is(value: unknown): value is string | string[];
@@ -285,7 +286,7 @@ export declare const inferCompletenessOp: import("./define-operation.js").Define
                 [x: string]: unknown;
                 from: string;
                 to: string;
-                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
                 description?: string | string[] | undefined;
                 polarity?: "positive" | "negative" | "neutral" | "uncertain" | undefined;
                 strength?: number | undefined;
@@ -376,7 +377,7 @@ export declare const inferCompletenessOp: import("./define-operation.js").Define
                 [x: string]: unknown;
                 from: string;
                 to: string;
-                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
                 description?: string | string[] | undefined;
                 polarity?: "positive" | "negative" | "neutral" | "uncertain" | undefined;
                 strength?: number | undefined;

package/dist/src/operations/infer-derived.d.ts

@@ -238,8 +238,9 @@ export declare const inferDerivedOp: import("./define-operation.js").DefinedOper
                 requires: "requires";
                 disables: "disables";
                 influence: "influence";
+                justifies: "justifies";
             }> & {
-                is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
             };
             description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
                 is(value: unknown): value is string | string[];
@@ -258,7 +259,7 @@ export declare const inferDerivedOp: import("./define-operation.js").DefinedOper
                 [x: string]: unknown;
                 from: string;
                 to: string;
-                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
                 description?: string | string[] | undefined;
                 polarity?: "positive" | "negative" | "neutral" | "uncertain" | undefined;
                 strength?: number | undefined;
@@ -349,7 +350,7 @@ export declare const inferDerivedOp: import("./define-operation.js").DefinedOper
                 [x: string]: unknown;
                 from: string;
                 to: string;
-                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence";
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables" | "influence" | "justifies";
                 description?: string | string[] | undefined;
                 polarity?: "positive" | "negative" | "neutral" | "uncertain" | undefined;
                 strength?: number | undefined;