@skhema/method 0.2.0 → 0.3.0

package/dist/definitions.js

@@ -1,9 +1,9 @@
-import { COMPONENT_TYPES, ELEMENT_TYPES, SKHEMA_MAPPING, } from "@skhema/types/schema";
+import { COMPONENT_TYPES, ELEMENT_TYPES, SKHEMA_MAPPING, } from './vocabulary/index.js';
 function titleCase(value) {
     return value
-        .split("_")
+        .split('_')
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(" ");
+        .join(' ');
 }
 function syntacticSlot(id, description, required = true) {
     return { id, label: titleCase(id), description, required };
@@ -17,10 +17,10 @@ function methodSlot(id, description, options = {}) {
         description,
         required,
         substitutable: options.substitutable ?? true,
-        cardinality: options.cardinality ?? (required ? "exactly_one" : "zero_or_one"),
+        cardinality: options.cardinality ?? (required ? 'exactly_one' : 'zero_or_one'),
         evidence: options.evidence ??
-            (required ? "explicit_span_required" : "explicit_or_inferred"),
-        inference: options.inference ?? (required ? "not_allowed" : "allowed"),
+            (required ? 'explicit_span_required' : 'explicit_or_inferred'),
+        inference: options.inference ?? (required ? 'not_allowed' : 'allowed'),
         acceptedEntityTypes: options.acceptedEntityTypes ?? [],
         diagnostics: options.diagnostics ?? {
             ...(required ? { missing: `${slotLabel} is required.` } : {}),
@@ -39,688 +39,899 @@ function relationship(source, target, type, label, description, options = {}) {
         type,
         label,
         description,
-        cardinality: options.cardinality ?? "zero_or_more",
+        cardinality: options.cardinality ?? 'zero_or_more',
         requiredForCompleteness: options.requiredForCompleteness ?? false,
-        evidence: options.evidence ?? "semantic_alignment",
-        scope: options.scope ?? ["same_strategy", "same_workspace"],
+        evidence: options.evidence ?? 'semantic_alignment',
+        scope: options.scope ?? ['same_strategy', 'same_workspace'],
         diagnostics: options.diagnostics ?? {
-            ...(options.requiredForCompleteness ? { missing: `${label} is required for completeness.` } : {}),
+            ...(options.requiredForCompleteness
+                ? { missing: `${label} is required for completeness.` }
+                : {}),
             weak: `${label} needs clearer evidence.`,
         },
     };
 }
 const indicativeSyntax = [
-    syntacticSlot("subject", "Noun that describes the subject performing or experiencing the action."),
-    syntacticSlot("direct_object", "Noun that describes the direct object of the verb."),
-    syntacticSlot("indirect_object", "Noun that describes the indirect object of the verb.", false),
+    syntacticSlot('subject', 'Noun that describes the subject performing or experiencing the action.'),
+    syntacticSlot('direct_object', 'Noun that describes the direct object of the verb.'),
+    syntacticSlot('indirect_object', 'Noun that describes the indirect object of the verb.', false),
 ];
 const imperativeSyntax = [
-    syntacticSlot("verb", "Verb that describes the required action."),
-    syntacticSlot("subject", "Noun that describes the actor performing the action.", false),
-    syntacticSlot("direct_object", "Noun that describes the direct object of the verb."),
-    syntacticSlot("indirect_object", "Noun that describes the indirect object of the verb.", false),
+    syntacticSlot('verb', 'Verb that describes the required action.'),
+    syntacticSlot('subject', 'Noun that describes the actor performing the action.', false),
+    syntacticSlot('direct_object', 'Noun that describes the direct object of the verb.'),
+    syntacticSlot('indirect_object', 'Noun that describes the indirect object of the verb.', false),
 ];
 const nounPhraseSyntax = [
-    syntacticSlot("noun_phrase", "Noun phrase that names the strategic option or object."),
-    syntacticSlot("verb", "Verb used if the phrase expresses a discontinuance or transition.", false),
-    syntacticSlot("direct_object", "Noun that describes the direct object of the verb.", false),
-    syntacticSlot("indirect_object", "Noun that describes the indirect object of the verb.", false),
-    syntacticSlot("subject", "Noun that describes the actor performing the action.", false),
+    syntacticSlot('noun_phrase', 'Noun phrase that names the strategic option or object.'),
+    syntacticSlot('verb', 'Verb used if the phrase expresses a discontinuance or transition.', false),
+    syntacticSlot('direct_object', 'Noun that describes the direct object of the verb.', false),
+    syntacticSlot('indirect_object', 'Noun that describes the indirect object of the verb.', false),
+    syntacticSlot('subject', 'Noun that describes the actor performing the action.', false),
 ];
 const indicativeMethodSlots = [
-    methodSlot("adverbial_phrase", "Adverb phrase that modifies the subject or statement frame."),
-    methodSlot("noun_phrase", "Noun phrase that modifies the subject or statement frame."),
-    methodSlot("argument", "Phrase that specifies the main argument of the element."),
-    methodSlot("argument_modifier", "Phrase that modifies the main argument."),
-    methodSlot("agent", "Noun that describes an agent contributing to the concern.", { required: false }),
-    methodSlot("temporal_modifier", "Phrase that modifies the temporal aspect of the element.", {
+    methodSlot('adverbial_phrase', 'Adverb phrase that modifies the subject or statement frame.'),
+    methodSlot('noun_phrase', 'Noun phrase that modifies the subject or statement frame.'),
+    methodSlot('argument', 'Phrase that specifies the main argument of the element.'),
+    methodSlot('argument_modifier', 'Phrase that modifies the main argument.'),
+    methodSlot('agent', 'Noun that describes an agent contributing to the concern.', { required: false }),
+    methodSlot('temporal_modifier', 'Phrase that modifies the temporal aspect of the element.', {
         required: false,
-        examples: ["in the next 12 months", "by 2030", "in Q2 2025"],
+        examples: ['in the next 12 months', 'by 2030', 'in Q2 2025'],
     }),
 ];
 const imperativeMethodSlots = [
-    methodSlot("relative_clause", "Relative clause that modifies the noun phrase.", {
+    methodSlot('relative_clause', 'Relative clause that modifies the noun phrase.', {
         required: false,
     }),
-    methodSlot("adverbial_phrase", "Adverb phrase that modifies the verb action."),
+    methodSlot('adverbial_phrase', 'Adverb phrase that modifies the verb action.'),
 ];
 const keyChallengeSlots = [
-    methodSlot("actor", "The organization, team, market participant, customer group, or decision-maker facing the challenge.", {
-        cardinality: "one_or_more",
-        acceptedEntityTypes: ["organization", "segment", "market_participant"],
+    methodSlot('actor', 'The organization, team, market participant, customer group, or decision-maker facing the challenge.', {
+        cardinality: 'one_or_more',
+        acceptedEntityTypes: ['organization', 'segment', 'market_participant'],
         diagnostics: {
-            missing: "Identify who is facing the challenge.",
-            weak: "Make the actor specific enough to guide strategy work.",
+            missing: 'Identify who is facing the challenge.',
+            weak: 'Make the actor specific enough to guide strategy work.',
         },
     }),
-    methodSlot("causal_pressure", "The force, shift, constraint, or market change creating the challenge.", {
-        cardinality: "one_or_more",
+    methodSlot('causal_pressure', 'The force, shift, constraint, or market change creating the challenge.', {
+        cardinality: 'one_or_more',
         acceptedEntityTypes: [
-            "externality",
-            "constraint",
-            "market_shift",
-            "competitive_pressure",
-            "regulatory_pressure",
+            'externality',
+            'constraint',
+            'market_shift',
+            'competitive_pressure',
+            'regulatory_pressure',
         ],
         diagnostics: {
-            missing: "Describe the force or change creating the challenge.",
-            weak: "Make the causal pressure concrete enough to explain why the challenge exists.",
+            missing: 'Describe the force or change creating the challenge.',
+            weak: 'Make the causal pressure concrete enough to explain why the challenge exists.',
         },
     }),
-    methodSlot("consequence", "The material impact, risk, or strategic effect if the challenge is not addressed.", {
-        acceptedEntityTypes: ["impact", "metric", "risk", "outcome"],
+    methodSlot('consequence', 'The material impact, risk, or strategic effect if the challenge is not addressed.', {
+        acceptedEntityTypes: ['impact', 'metric', 'risk', 'outcome'],
         diagnostics: {
-            missing: "Describe the material consequence of not addressing the challenge.",
-            weak: "Make the consequence observable or strategically material.",
+            missing: 'Describe the material consequence of not addressing the challenge.',
+            weak: 'Make the consequence observable or strategically material.',
         },
     }),
-    methodSlot("industry_context", "The industry or sector context, if present.", {
+    methodSlot('industry_context', 'The industry or sector context, if present.', {
         required: false,
-        acceptedEntityTypes: ["industry"],
+        acceptedEntityTypes: ['industry'],
         diagnostics: {
-            weak: "Clarify the industry context if it changes the nature of the challenge.",
+            weak: 'Clarify the industry context if it changes the nature of the challenge.',
         },
     }),
-    methodSlot("geographic_context", "The location, market, or region context, if present.", {
+    methodSlot('geographic_context', 'The location, market, or region context, if present.', {
         required: false,
-        acceptedEntityTypes: ["geo", "market"],
+        acceptedEntityTypes: ['geo', 'market'],
         diagnostics: {
-            weak: "Clarify geography if the challenge depends on location or market boundaries.",
+            weak: 'Clarify geography if the challenge depends on location or market boundaries.',
         },
     }),
-    methodSlot("temporal_context", "The timeframe, deadline, period, or timing assumption, if present.", {
+    methodSlot('temporal_context', 'The timeframe, deadline, period, or timing assumption, if present.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify timing if urgency or sequencing affects the strategic response.",
+            weak: 'Clarify timing if urgency or sequencing affects the strategic response.',
         },
     }),
-    methodSlot("constraint", "A limiting condition, dependency, or tradeoff that narrows the challenge.", {
+    methodSlot('constraint', 'A limiting condition, dependency, or tradeoff that narrows the challenge.', {
         required: false,
-        acceptedEntityTypes: ["constraint", "dependency", "tradeoff"],
+        acceptedEntityTypes: ['constraint', 'dependency', 'tradeoff'],
         diagnostics: {
-            weak: "Clarify the constraint if it changes what responses are viable.",
+            weak: 'Clarify the constraint if it changes what responses are viable.',
         },
     }),
-    methodSlot("decision_object", "The specific judgement, decision, resource, capability, or strategic object being pressured.", {
+    methodSlot('decision_object', 'The specific judgement, decision, resource, capability, or strategic object being pressured.', {
         required: false,
-        acceptedEntityTypes: ["decision", "resource", "capability", "strategic_object"],
+        acceptedEntityTypes: [
+            'decision',
+            'resource',
+            'capability',
+            'strategic_object',
+        ],
         diagnostics: {
-            weak: "Clarify what decision or strategic object is under pressure.",
+            weak: 'Clarify what decision or strategic object is under pressure.',
         },
     }),
 ];
 const supportingFactSlots = [
-    methodSlot("subject", "The entity, activity, metric, market, or operating area the fact describes.", {
-        acceptedEntityTypes: ["organization", "segment", "metric", "market", "capability"],
+    methodSlot('subject', 'The entity, activity, metric, market, or operating area the fact describes.', {
+        acceptedEntityTypes: [
+            'organization',
+            'segment',
+            'metric',
+            'market',
+            'capability',
+        ],
         diagnostics: {
-            missing: "Identify what the supporting fact is about.",
-            weak: "Make the subject of the fact specific enough to support a challenge.",
+            missing: 'Identify what the supporting fact is about.',
+            weak: 'Make the subject of the fact specific enough to support a challenge.',
         },
     }),
-    methodSlot("evidence", "The observed fact, measurement, event, or data point that supports strategic judgement.", {
-        acceptedEntityTypes: ["metric", "event", "observation", "evidence"],
+    methodSlot('evidence', 'The observed fact, measurement, event, or data point that supports strategic judgement.', {
+        acceptedEntityTypes: ['metric', 'event', 'observation', 'evidence'],
         diagnostics: {
-            missing: "State the observed fact or evidence.",
-            weak: "Make the evidence concrete enough to be tested or cited.",
+            missing: 'State the observed fact or evidence.',
+            weak: 'Make the evidence concrete enough to be tested or cited.',
         },
     }),
-    methodSlot("direction", "The movement, comparison, or directional change in the evidence.", {
+    methodSlot('direction', 'The movement, comparison, or directional change in the evidence.', {
         required: false,
-        acceptedEntityTypes: ["trend", "comparison", "directional_change"],
+        acceptedEntityTypes: ['trend', 'comparison', 'directional_change'],
         diagnostics: {
-            weak: "Clarify whether the fact is increasing, decreasing, stable, above, or below a reference point.",
+            weak: 'Clarify whether the fact is increasing, decreasing, stable, above, or below a reference point.',
         },
     }),
-    methodSlot("temporal_context", "The timeframe or period in which the fact applies.", {
+    methodSlot('temporal_context', 'The timeframe or period in which the fact applies.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify the time period for the supporting fact.",
+            weak: 'Clarify the time period for the supporting fact.',
         },
     }),
-    methodSlot("source_context", "The source, basis, or measurement context for the fact.", {
+    methodSlot('source_context', 'The source, basis, or measurement context for the fact.', {
         required: false,
         substitutable: false,
-        acceptedEntityTypes: ["source", "dataset", "report", "experiment"],
+        acceptedEntityTypes: ['source', 'dataset', 'report', 'experiment'],
         diagnostics: {
-            weak: "Add the source or measurement basis if the fact needs auditability.",
+            weak: 'Add the source or measurement basis if the fact needs auditability.',
         },
     }),
 ];
 const impactSlots = [
-    methodSlot("affected_object", "The business outcome, stakeholder, asset, capability, or metric affected by the challenge.", {
-        acceptedEntityTypes: ["outcome", "metric", "stakeholder", "asset", "capability"],
+    methodSlot('affected_object', 'The business outcome, stakeholder, asset, capability, or metric affected by the challenge.', {
+        acceptedEntityTypes: [
+            'outcome',
+            'metric',
+            'stakeholder',
+            'asset',
+            'capability',
+        ],
         diagnostics: {
-            missing: "Identify what is affected.",
-            weak: "Make the affected object specific enough to reason about consequences.",
+            missing: 'Identify what is affected.',
+            weak: 'Make the affected object specific enough to reason about consequences.',
         },
     }),
-    methodSlot("impact_mechanism", "The causal mechanism by which the challenge creates the impact.", {
-        acceptedEntityTypes: ["causal_mechanism", "constraint", "externality", "process"],
+    methodSlot('impact_mechanism', 'The causal mechanism by which the challenge creates the impact.', {
+        acceptedEntityTypes: [
+            'causal_mechanism',
+            'constraint',
+            'externality',
+            'process',
+        ],
         diagnostics: {
-            missing: "Explain how the challenge creates the impact.",
-            weak: "Make the causal mechanism clearer.",
+            missing: 'Explain how the challenge creates the impact.',
+            weak: 'Make the causal mechanism clearer.',
         },
     }),
-    methodSlot("impact_magnitude", "The scale, severity, or materiality of the impact.", {
+    methodSlot('impact_magnitude', 'The scale, severity, or materiality of the impact.', {
         required: false,
-        acceptedEntityTypes: ["metric", "risk", "severity", "estimate"],
+        acceptedEntityTypes: ['metric', 'risk', 'severity', 'estimate'],
         diagnostics: {
-            weak: "Clarify the scale or materiality of the impact if known.",
+            weak: 'Clarify the scale or materiality of the impact if known.',
         },
     }),
-    methodSlot("temporal_context", "The timeframe over which the impact occurs or becomes material.", {
+    methodSlot('temporal_context', 'The timeframe over which the impact occurs or becomes material.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify when the impact occurs or becomes material.",
+            weak: 'Clarify when the impact occurs or becomes material.',
         },
     }),
-    methodSlot("downstream_consequence", "The further strategic consequence created by the immediate impact.", {
+    methodSlot('downstream_consequence', 'The further strategic consequence created by the immediate impact.', {
         required: false,
-        acceptedEntityTypes: ["consequence", "risk", "outcome"],
+        acceptedEntityTypes: ['consequence', 'risk', 'outcome'],
         diagnostics: {
-            weak: "Clarify the downstream consequence if it changes the strategic response.",
+            weak: 'Clarify the downstream consequence if it changes the strategic response.',
         },
     }),
 ];
 const guidingPolicySlots = [
-    methodSlot("strategic_action", "The coherent action, posture, or policy direction that addresses the key challenge.", {
-        acceptedEntityTypes: ["approach", "method", "move", "position"],
+    methodSlot('strategic_action', 'The coherent action, posture, or policy direction that addresses the key challenge.', {
+        acceptedEntityTypes: ['approach', 'method', 'move', 'position'],
         diagnostics: {
-            missing: "State the strategic action or policy direction.",
-            weak: "Make the policy direction specific enough to guide choices.",
+            missing: 'State the strategic action or policy direction.',
+            weak: 'Make the policy direction specific enough to guide choices.',
         },
     }),
-    methodSlot("decision_object", "The market, capability, offer, activity, resource, or choice the policy acts on.", {
-        acceptedEntityTypes: ["market", "capability", "product", "service", "resource", "activity"],
+    methodSlot('decision_object', 'The market, capability, offer, activity, resource, or choice the policy acts on.', {
+        acceptedEntityTypes: [
+            'market',
+            'capability',
+            'product',
+            'service',
+            'resource',
+            'activity',
+        ],
         diagnostics: {
-            missing: "Identify what the guiding policy acts on.",
-            weak: "Make the decision object concrete enough to constrain action.",
+            missing: 'Identify what the guiding policy acts on.',
+            weak: 'Make the decision object concrete enough to constrain action.',
         },
     }),
-    methodSlot("advantage_logic", "The rationale for why this policy creates advantage or resolves the challenge.", {
+    methodSlot('advantage_logic', 'The rationale for why this policy creates advantage or resolves the challenge.', {
         required: false,
-        acceptedEntityTypes: ["advantage", "capability", "mechanism", "tradeoff"],
+        acceptedEntityTypes: ['advantage', 'capability', 'mechanism', 'tradeoff'],
         diagnostics: {
-            weak: "Clarify why this policy is expected to work.",
+            weak: 'Clarify why this policy is expected to work.',
         },
     }),
-    methodSlot("boundary", "The explicit limit, exclusion, or tradeoff implied by the policy.", {
+    methodSlot('boundary', 'The explicit limit, exclusion, or tradeoff implied by the policy.', {
         required: false,
-        acceptedEntityTypes: ["scope", "constraint", "tradeoff"],
+        acceptedEntityTypes: ['scope', 'constraint', 'tradeoff'],
         diagnostics: {
-            weak: "Clarify the boundary or tradeoff if the policy could be interpreted too broadly.",
+            weak: 'Clarify the boundary or tradeoff if the policy could be interpreted too broadly.',
         },
     }),
 ];
 const competitorMoveSlots = [
-    methodSlot("competitor", "The competitor, substitute, entrant, channel, or market participant making the move.", {
-        acceptedEntityTypes: ["organization", "competitor", "substitute", "entrant", "channel"],
+    methodSlot('competitor', 'The competitor, substitute, entrant, channel, or market participant making the move.', {
+        acceptedEntityTypes: [
+            'organization',
+            'competitor',
+            'substitute',
+            'entrant',
+            'channel',
+        ],
         diagnostics: {
-            missing: "Identify who is making the competitor move.",
-            weak: "Make the competitor or market participant specific.",
+            missing: 'Identify who is making the competitor move.',
+            weak: 'Make the competitor or market participant specific.',
         },
     }),
-    methodSlot("move", "The competitive action, investment, pricing change, distribution shift, or strategic posture being taken.", {
-        acceptedEntityTypes: ["move", "investment", "pricing", "distribution", "position"],
+    methodSlot('move', 'The competitive action, investment, pricing change, distribution shift, or strategic posture being taken.', {
+        acceptedEntityTypes: [
+            'move',
+            'investment',
+            'pricing',
+            'distribution',
+            'position',
+        ],
         diagnostics: {
-            missing: "Describe the competitive move.",
-            weak: "Make the competitive action observable enough to track.",
+            missing: 'Describe the competitive move.',
+            weak: 'Make the competitive action observable enough to track.',
         },
     }),
-    methodSlot("threat_logic", "Why the move matters for the organization's challenge, policy, or advantage.", {
+    methodSlot('threat_logic', "Why the move matters for the organization's challenge, policy, or advantage.", {
         required: false,
-        acceptedEntityTypes: ["threat", "pressure", "advantage", "risk"],
+        acceptedEntityTypes: ['threat', 'pressure', 'advantage', 'risk'],
         diagnostics: {
-            weak: "Clarify why this competitor move is strategically relevant.",
+            weak: 'Clarify why this competitor move is strategically relevant.',
         },
     }),
-    methodSlot("temporal_context", "The timeframe in which the move is occurring or expected.", {
+    methodSlot('temporal_context', 'The timeframe in which the move is occurring or expected.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify when the move is occurring or expected.",
+            weak: 'Clarify when the move is occurring or expected.',
         },
     }),
 ];
 const scopeSlots = [
-    methodSlot("included_domain", "The market, customer segment, geography, category, product, service, channel, or activity included in scope.", {
-        cardinality: "one_or_more",
-        acceptedEntityTypes: ["market", "segment", "geo", "category", "product", "service", "channel", "activity"],
+    methodSlot('included_domain', 'The market, customer segment, geography, category, product, service, channel, or activity included in scope.', {
+        cardinality: 'one_or_more',
+        acceptedEntityTypes: [
+            'market',
+            'segment',
+            'geo',
+            'category',
+            'product',
+            'service',
+            'channel',
+            'activity',
+        ],
         diagnostics: {
-            missing: "Identify what is included in scope.",
-            weak: "Make the included scope specific enough to guide choices.",
+            missing: 'Identify what is included in scope.',
+            weak: 'Make the included scope specific enough to guide choices.',
         },
     }),
-    methodSlot("scope_action", "The action implied by the scope statement, such as target, prioritize, enter, avoid, or limit.", {
+    methodSlot('scope_action', 'The action implied by the scope statement, such as target, prioritize, enter, avoid, or limit.', {
         required: false,
-        acceptedEntityTypes: ["action", "priority", "boundary"],
+        acceptedEntityTypes: ['action', 'priority', 'boundary'],
         diagnostics: {
-            weak: "Clarify the action implied by the scope statement.",
+            weak: 'Clarify the action implied by the scope statement.',
         },
     }),
-    methodSlot("excluded_domain", "The domain explicitly excluded or deprioritized by the scope.", {
+    methodSlot('excluded_domain', 'The domain explicitly excluded or deprioritized by the scope.', {
         required: false,
-        acceptedEntityTypes: ["market", "segment", "geo", "category", "product", "service", "channel", "activity"],
+        acceptedEntityTypes: [
+            'market',
+            'segment',
+            'geo',
+            'category',
+            'product',
+            'service',
+            'channel',
+            'activity',
+        ],
         diagnostics: {
-            weak: "Clarify what is outside scope if the boundary matters.",
+            weak: 'Clarify what is outside scope if the boundary matters.',
         },
     }),
-    methodSlot("boundary_condition", "The threshold, condition, or criterion that defines the scope boundary.", {
+    methodSlot('boundary_condition', 'The threshold, condition, or criterion that defines the scope boundary.', {
         required: false,
-        acceptedEntityTypes: ["metric", "threshold", "condition", "criterion"],
+        acceptedEntityTypes: ['metric', 'threshold', 'condition', 'criterion'],
         diagnostics: {
-            weak: "Clarify the threshold or criterion that defines the scope boundary.",
+            weak: 'Clarify the threshold or criterion that defines the scope boundary.',
         },
     }),
 ];
 const constraintSlots = [
-    methodSlot("constraint_source", "The internal or external source creating the limitation.", {
-        acceptedEntityTypes: ["internality", "externality", "regulation", "resource", "capability", "market"],
+    methodSlot('constraint_source', 'The internal or external source creating the limitation.', {
+        acceptedEntityTypes: [
+            'internality',
+            'externality',
+            'regulation',
+            'resource',
+            'capability',
+            'market',
+        ],
         diagnostics: {
-            missing: "Identify the source of the constraint.",
-            weak: "Make the constraint source specific enough to reason about.",
+            missing: 'Identify the source of the constraint.',
+            weak: 'Make the constraint source specific enough to reason about.',
         },
     }),
-    methodSlot("limitation", "The limit, dependency, threshold, or condition that restricts viable choices.", {
-        acceptedEntityTypes: ["constraint", "dependency", "threshold", "condition", "tradeoff"],
+    methodSlot('limitation', 'The limit, dependency, threshold, or condition that restricts viable choices.', {
+        acceptedEntityTypes: [
+            'constraint',
+            'dependency',
+            'threshold',
+            'condition',
+            'tradeoff',
+        ],
         diagnostics: {
-            missing: "Describe the limitation imposed by the constraint.",
-            weak: "Make the limitation concrete enough to constrain action.",
+            missing: 'Describe the limitation imposed by the constraint.',
+            weak: 'Make the limitation concrete enough to constrain action.',
         },
     }),
-    methodSlot("affected_choice", "The policy, solution, action, investment, or capability affected by the constraint.", {
+    methodSlot('affected_choice', 'The policy, solution, action, investment, or capability affected by the constraint.', {
         required: false,
-        acceptedEntityTypes: ["guiding_policy", "solution", "action", "investment", "capability"],
+        acceptedEntityTypes: [
+            'guiding_policy',
+            'solution',
+            'action',
+            'investment',
+            'capability',
+        ],
         diagnostics: {
-            weak: "Clarify what choice the constraint affects.",
+            weak: 'Clarify what choice the constraint affects.',
         },
     }),
-    methodSlot("constraint_type", "The category of constraint, such as fiscal, regulatory, competitive, technological, environmental, social, temporal, internal, or external.", {
+    methodSlot('constraint_type', 'The category of constraint, such as fiscal, regulatory, competitive, technological, environmental, social, temporal, internal, or external.', {
         required: false,
-        acceptedEntityTypes: ["constraint_type"],
+        acceptedEntityTypes: ['constraint_type'],
         diagnostics: {
-            weak: "Classify the constraint if type changes how it should be handled.",
+            weak: 'Classify the constraint if type changes how it should be handled.',
         },
     }),
 ];
 const solutionSlots = [
-    methodSlot("solution_object", "The option, initiative, intervention, product, process, or strategic move being considered.", {
-        acceptedEntityTypes: ["solution", "initiative", "product", "process", "move", "intervention"],
+    methodSlot('solution_object', 'The option, initiative, intervention, product, process, or strategic move being considered.', {
+        acceptedEntityTypes: [
+            'solution',
+            'initiative',
+            'product',
+            'process',
+            'move',
+            'intervention',
+        ],
         diagnostics: {
-            missing: "Identify the solution or strategic option being considered.",
-            weak: "Make the solution object specific enough to evaluate.",
+            missing: 'Identify the solution or strategic option being considered.',
+            weak: 'Make the solution object specific enough to evaluate.',
         },
     }),
-    methodSlot("mechanism", "How the solution is expected to address the guiding policy or key challenge.", {
+    methodSlot('mechanism', 'How the solution is expected to address the guiding policy or key challenge.', {
         required: false,
-        acceptedEntityTypes: ["mechanism", "capability", "process", "advantage"],
+        acceptedEntityTypes: ['mechanism', 'capability', 'process', 'advantage'],
         diagnostics: {
-            weak: "Clarify how this solution is expected to work.",
+            weak: 'Clarify how this solution is expected to work.',
         },
     }),
-    methodSlot("target_context", "The customer, market, geography, product, channel, capability, or activity the solution targets.", {
+    methodSlot('target_context', 'The customer, market, geography, product, channel, capability, or activity the solution targets.', {
         required: false,
-        acceptedEntityTypes: ["segment", "market", "geo", "product", "channel", "capability", "activity"],
+        acceptedEntityTypes: [
+            'segment',
+            'market',
+            'geo',
+            'product',
+            'channel',
+            'capability',
+            'activity',
+        ],
         diagnostics: {
-            weak: "Clarify the context or target for the solution.",
+            weak: 'Clarify the context or target for the solution.',
         },
     }),
-    methodSlot("tradeoff", "The sacrifice, exclusion, cost, or risk implied by choosing this solution.", {
+    methodSlot('tradeoff', 'The sacrifice, exclusion, cost, or risk implied by choosing this solution.', {
         required: false,
-        acceptedEntityTypes: ["tradeoff", "cost", "risk", "constraint"],
+        acceptedEntityTypes: ['tradeoff', 'cost', 'risk', 'constraint'],
         diagnostics: {
-            weak: "Clarify the tradeoff if it affects whether the solution is viable.",
+            weak: 'Clarify the tradeoff if it affects whether the solution is viable.',
         },
     }),
 ];
 const assumptionHypothesisSlots = [
-    methodSlot("belief", "The unproven belief, condition, or causal claim that must hold true.", {
-        acceptedEntityTypes: ["belief", "condition", "claim", "causal_assumption"],
+    methodSlot('belief', 'The unproven belief, condition, or causal claim that must hold true.', {
+        acceptedEntityTypes: [
+            'belief',
+            'condition',
+            'claim',
+            'causal_assumption',
+        ],
         diagnostics: {
-            missing: "State the assumption or hypothesis that must be true.",
-            weak: "Make the assumption specific enough to test.",
+            missing: 'State the assumption or hypothesis that must be true.',
+            weak: 'Make the assumption specific enough to test.',
         },
     }),
-    methodSlot("dependent_outcome", "The outcome, behavior, metric, or result that depends on the assumption being true.", {
+    methodSlot('dependent_outcome', 'The outcome, behavior, metric, or result that depends on the assumption being true.', {
         required: false,
-        acceptedEntityTypes: ["outcome", "behavior", "metric", "result"],
+        acceptedEntityTypes: ['outcome', 'behavior', 'metric', 'result'],
         diagnostics: {
-            weak: "Clarify what outcome depends on this assumption.",
+            weak: 'Clarify what outcome depends on this assumption.',
         },
     }),
-    methodSlot("test_condition", "The observable condition or evidence that would confirm or disconfirm the assumption.", {
+    methodSlot('test_condition', 'The observable condition or evidence that would confirm or disconfirm the assumption.', {
         required: false,
-        acceptedEntityTypes: ["evidence", "metric", "threshold", "condition"],
+        acceptedEntityTypes: ['evidence', 'metric', 'threshold', 'condition'],
         diagnostics: {
-            weak: "Clarify how this assumption could be tested.",
+            weak: 'Clarify how this assumption could be tested.',
         },
     }),
-    methodSlot("timeframe", "The period over which the assumption should hold or be tested.", {
+    methodSlot('timeframe', 'The period over which the assumption should hold or be tested.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify the timeframe for this assumption.",
+            weak: 'Clarify the timeframe for this assumption.',
         },
     }),
 ];
 const experimentSlots = [
-    methodSlot("test_action", "The experiment, pilot, model, trial, survey, or analysis to perform.", {
-        acceptedEntityTypes: ["experiment", "pilot", "model", "survey", "analysis", "test"],
+    methodSlot('test_action', 'The experiment, pilot, model, trial, survey, or analysis to perform.', {
+        acceptedEntityTypes: [
+            'experiment',
+            'pilot',
+            'model',
+            'survey',
+            'analysis',
+            'test',
+        ],
         diagnostics: {
-            missing: "State the test action to perform.",
-            weak: "Make the experiment action specific enough to execute.",
+            missing: 'State the test action to perform.',
+            weak: 'Make the experiment action specific enough to execute.',
         },
     }),
-    methodSlot("hypothesis_under_test", "The assumption, hypothesis, or uncertainty the experiment is designed to test.", {
+    methodSlot('hypothesis_under_test', 'The assumption, hypothesis, or uncertainty the experiment is designed to test.', {
         required: false,
-        acceptedEntityTypes: ["assumption_hypothesis", "uncertainty", "belief"],
+        acceptedEntityTypes: ['assumption_hypothesis', 'uncertainty', 'belief'],
         diagnostics: {
-            weak: "Clarify what assumption or uncertainty this experiment tests.",
+            weak: 'Clarify what assumption or uncertainty this experiment tests.',
         },
     }),
-    methodSlot("success_metric", "The metric, threshold, or evidence that determines the result of the experiment.", {
+    methodSlot('success_metric', 'The metric, threshold, or evidence that determines the result of the experiment.', {
         required: false,
-        acceptedEntityTypes: ["metric", "threshold", "evidence"],
+        acceptedEntityTypes: ['metric', 'threshold', 'evidence'],
         diagnostics: {
-            weak: "Clarify how the experiment result will be judged.",
+            weak: 'Clarify how the experiment result will be judged.',
         },
     }),
-    methodSlot("sample_or_scope", "The sample, audience, geography, product set, or operating scope of the experiment.", {
+    methodSlot('sample_or_scope', 'The sample, audience, geography, product set, or operating scope of the experiment.', {
         required: false,
-        acceptedEntityTypes: ["segment", "sample", "geo", "product", "scope"],
+        acceptedEntityTypes: ['segment', 'sample', 'geo', 'product', 'scope'],
         diagnostics: {
-            weak: "Clarify the experiment scope.",
+            weak: 'Clarify the experiment scope.',
         },
     }),
 ];
 const actionSlots = [
-    methodSlot("action", "The concrete task, decision, change, or implementation step to perform.", {
-        acceptedEntityTypes: ["action", "task", "decision", "change", "implementation_step"],
+    methodSlot('action', 'The concrete task, decision, change, or implementation step to perform.', {
+        acceptedEntityTypes: [
+            'action',
+            'task',
+            'decision',
+            'change',
+            'implementation_step',
+        ],
         diagnostics: {
-            missing: "State the concrete action to perform.",
-            weak: "Make the action specific enough to assign or execute.",
+            missing: 'State the concrete action to perform.',
+            weak: 'Make the action specific enough to assign or execute.',
         },
     }),
-    methodSlot("owner_or_actor", "The person, team, function, or partner responsible for the action.", {
+    methodSlot('owner_or_actor', 'The person, team, function, or partner responsible for the action.', {
         required: false,
-        acceptedEntityTypes: ["person", "team", "function", "partner", "organization"],
+        acceptedEntityTypes: [
+            'person',
+            'team',
+            'function',
+            'partner',
+            'organization',
+        ],
         diagnostics: {
-            weak: "Clarify who owns or performs the action.",
+            weak: 'Clarify who owns or performs the action.',
         },
     }),
-    methodSlot("target_object", "The process, product, customer, system, resource, or activity the action changes.", {
+    methodSlot('target_object', 'The process, product, customer, system, resource, or activity the action changes.', {
         required: false,
-        acceptedEntityTypes: ["process", "product", "customer", "system", "resource", "activity"],
+        acceptedEntityTypes: [
+            'process',
+            'product',
+            'customer',
+            'system',
+            'resource',
+            'activity',
+        ],
         diagnostics: {
-            weak: "Clarify what the action changes.",
+            weak: 'Clarify what the action changes.',
         },
     }),
-    methodSlot("timeframe", "The deadline, cadence, or timing of the action.", {
+    methodSlot('timeframe', 'The deadline, cadence, or timing of the action.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify when the action should happen.",
+            weak: 'Clarify when the action should happen.',
         },
     }),
 ];
 const investmentSlots = [
-    methodSlot("investment_amount", "The quantity of capital, resources, or effort to invest.", {
-        acceptedEntityTypes: ["metric", "currency", "quantity", "resource"],
+    methodSlot('investment_amount', 'The quantity of capital, resources, or effort to invest.', {
+        acceptedEntityTypes: ['metric', 'currency', 'quantity', 'resource'],
         diagnostics: {
-            missing: "State the investment amount or resource commitment.",
-            weak: "Make the investment amount specific enough to compare.",
+            missing: 'State the investment amount or resource commitment.',
+            weak: 'Make the investment amount specific enough to compare.',
         },
     }),
-    methodSlot("investment_type", "The category or object of investment.", {
-        acceptedEntityTypes: ["capability", "system", "asset", "initiative", "resource"],
+    methodSlot('investment_type', 'The category or object of investment.', {
+        acceptedEntityTypes: [
+            'capability',
+            'system',
+            'asset',
+            'initiative',
+            'resource',
+        ],
         diagnostics: {
-            missing: "Identify what type of investment is being considered.",
-            weak: "Make the investment type specific.",
+            missing: 'Identify what type of investment is being considered.',
+            weak: 'Make the investment type specific.',
         },
     }),
-    methodSlot("investment_period", "The timeframe over which the investment is made or evaluated.", {
+    methodSlot('investment_period', 'The timeframe over which the investment is made or evaluated.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify the investment period.",
+            weak: 'Clarify the investment period.',
         },
     }),
 ];
 const estimateSlots = [
-    methodSlot("estimate_amount", "The estimated quantity, value, range, or probability.", {
-        acceptedEntityTypes: ["metric", "currency", "quantity", "probability", "range"],
+    methodSlot('estimate_amount', 'The estimated quantity, value, range, or probability.', {
+        acceptedEntityTypes: [
+            'metric',
+            'currency',
+            'quantity',
+            'probability',
+            'range',
+        ],
         diagnostics: {
-            missing: "State the estimate amount, value, range, or probability.",
-            weak: "Make the estimate specific enough to compare or revise.",
+            missing: 'State the estimate amount, value, range, or probability.',
+            weak: 'Make the estimate specific enough to compare or revise.',
         },
     }),
-    methodSlot("estimate_type", "The metric, outcome, cost, revenue, share, volume, or effect being estimated.", {
-        acceptedEntityTypes: ["metric", "outcome", "cost", "revenue", "share", "volume"],
+    methodSlot('estimate_type', 'The metric, outcome, cost, revenue, share, volume, or effect being estimated.', {
+        acceptedEntityTypes: [
+            'metric',
+            'outcome',
+            'cost',
+            'revenue',
+            'share',
+            'volume',
+        ],
         diagnostics: {
-            missing: "Identify what is being estimated.",
-            weak: "Make the estimate type specific.",
+            missing: 'Identify what is being estimated.',
+            weak: 'Make the estimate type specific.',
         },
     }),
-    methodSlot("estimate_period", "The timeframe or period for the estimate.", {
+    methodSlot('estimate_period', 'The timeframe or period for the estimate.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify the estimate period.",
+            weak: 'Clarify the estimate period.',
         },
     }),
-    methodSlot("basis", "The assumption, experiment, benchmark, or source that supports the estimate.", {
+    methodSlot('basis', 'The assumption, experiment, benchmark, or source that supports the estimate.', {
         required: false,
         substitutable: false,
-        acceptedEntityTypes: ["assumption_hypothesis", "experiment", "benchmark", "source"],
+        acceptedEntityTypes: [
+            'assumption_hypothesis',
+            'experiment',
+            'benchmark',
+            'source',
+        ],
         diagnostics: {
-            weak: "Clarify the basis for the estimate if auditability matters.",
+            weak: 'Clarify the basis for the estimate if auditability matters.',
         },
     }),
 ];
 const baselineSlots = [
-    methodSlot("measured_object", "The metric, process, behavior, asset, segment, or outcome being measured as the starting point.", {
-        acceptedEntityTypes: ["metric", "process", "behavior", "asset", "segment", "outcome"],
+    methodSlot('measured_object', 'The metric, process, behavior, asset, segment, or outcome being measured as the starting point.', {
+        acceptedEntityTypes: [
+            'metric',
+            'process',
+            'behavior',
+            'asset',
+            'segment',
+            'outcome',
+        ],
         diagnostics: {
-            missing: "Identify what the baseline measures.",
-            weak: "Make the measured object specific enough to compare against future outcomes.",
+            missing: 'Identify what the baseline measures.',
+            weak: 'Make the measured object specific enough to compare against future outcomes.',
         },
     }),
-    methodSlot("baseline_value", "The starting value, level, state, quantity, or condition before intervention.", {
-        acceptedEntityTypes: ["metric", "quantity", "state", "condition", "value"],
+    methodSlot('baseline_value', 'The starting value, level, state, quantity, or condition before intervention.', {
+        acceptedEntityTypes: [
+            'metric',
+            'quantity',
+            'state',
+            'condition',
+            'value',
+        ],
         diagnostics: {
-            missing: "State the baseline value or starting condition.",
-            weak: "Make the baseline value specific enough to compare.",
+            missing: 'State the baseline value or starting condition.',
+            weak: 'Make the baseline value specific enough to compare.',
         },
     }),
-    methodSlot("measurement_period", "The period over which the baseline was measured.", {
+    methodSlot('measurement_period', 'The period over which the baseline was measured.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify the measurement period for the baseline.",
+            weak: 'Clarify the measurement period for the baseline.',
         },
     }),
-    methodSlot("source_context", "The source, dataset, system, or evidence basis for the baseline.", {
+    methodSlot('source_context', 'The source, dataset, system, or evidence basis for the baseline.', {
         required: false,
         substitutable: false,
-        acceptedEntityTypes: ["source", "dataset", "system", "evidence"],
+        acceptedEntityTypes: ['source', 'dataset', 'system', 'evidence'],
         diagnostics: {
-            weak: "Clarify the source of the baseline if auditability matters.",
+            weak: 'Clarify the source of the baseline if auditability matters.',
         },
     }),
-    methodSlot("comparison_context", "The comparator, prior period, benchmark, or reference point used to interpret the baseline.", {
+    methodSlot('comparison_context', 'The comparator, prior period, benchmark, or reference point used to interpret the baseline.', {
         required: false,
-        acceptedEntityTypes: ["benchmark", "prior_period", "reference_point", "comparison"],
+        acceptedEntityTypes: [
+            'benchmark',
+            'prior_period',
+            'reference_point',
+            'comparison',
+        ],
         diagnostics: {
-            weak: "Clarify the comparison context if it affects interpretation.",
+            weak: 'Clarify the comparison context if it affects interpretation.',
         },
     }),
 ];
 const outcomeSlots = [
-    methodSlot("target_object", "The metric, business result, customer behavior, capability, or strategic state targeted by the strategy.", {
-        acceptedEntityTypes: ["metric", "outcome", "behavior", "capability", "strategic_state"],
+    methodSlot('target_object', 'The metric, business result, customer behavior, capability, or strategic state targeted by the strategy.', {
+        acceptedEntityTypes: [
+            'metric',
+            'outcome',
+            'behavior',
+            'capability',
+            'strategic_state',
+        ],
         diagnostics: {
-            missing: "Identify what outcome is being targeted.",
-            weak: "Make the outcome object specific enough to measure.",
+            missing: 'Identify what outcome is being targeted.',
+            weak: 'Make the outcome object specific enough to measure.',
         },
     }),
-    methodSlot("target_value", "The desired value, state, quantity, threshold, or direction of the outcome.", {
-        acceptedEntityTypes: ["metric", "quantity", "threshold", "state", "direction"],
+    methodSlot('target_value', 'The desired value, state, quantity, threshold, or direction of the outcome.', {
+        acceptedEntityTypes: [
+            'metric',
+            'quantity',
+            'threshold',
+            'state',
+            'direction',
+        ],
         diagnostics: {
-            missing: "State the target value or desired state.",
-            weak: "Make the target value specific enough to judge success.",
+            missing: 'State the target value or desired state.',
+            weak: 'Make the target value specific enough to judge success.',
         },
     }),
-    methodSlot("timeframe", "The timeframe by which the outcome should be achieved or assessed.", {
+    methodSlot('timeframe', 'The timeframe by which the outcome should be achieved or assessed.', {
         required: false,
-        acceptedEntityTypes: ["timeframe"],
+        acceptedEntityTypes: ['timeframe'],
         diagnostics: {
-            weak: "Clarify when the outcome should be achieved.",
+            weak: 'Clarify when the outcome should be achieved.',
         },
     }),
-    methodSlot("success_condition", "The condition under which the outcome should be considered achieved.", {
+    methodSlot('success_condition', 'The condition under which the outcome should be considered achieved.', {
         required: false,
-        acceptedEntityTypes: ["condition", "threshold", "metric"],
+        acceptedEntityTypes: ['condition', 'threshold', 'metric'],
         diagnostics: {
-            weak: "Clarify what would count as success.",
+            weak: 'Clarify what would count as success.',
         },
     }),
-    methodSlot("strategic_effect", "The strategic effect or business consequence expected if the outcome is achieved.", {
+    methodSlot('strategic_effect', 'The strategic effect or business consequence expected if the outcome is achieved.', {
         required: false,
-        acceptedEntityTypes: ["effect", "consequence", "advantage", "impact"],
+        acceptedEntityTypes: ['effect', 'consequence', 'advantage', 'impact'],
         diagnostics: {
-            weak: "Clarify why this outcome matters strategically.",
+            weak: 'Clarify why this outcome matters strategically.',
         },
     }),
 ];
 const performanceVariableSlots = [
-    methodSlot("metric", "The variable, metric, indicator, or measure used to track performance.", {
-        acceptedEntityTypes: ["metric", "indicator", "measure", "variable"],
+    methodSlot('metric', 'The variable, metric, indicator, or measure used to track performance.', {
+        acceptedEntityTypes: ['metric', 'indicator', 'measure', 'variable'],
         diagnostics: {
-            missing: "Identify the performance variable to track.",
-            weak: "Make the performance variable specific enough to measure.",
+            missing: 'Identify the performance variable to track.',
+            weak: 'Make the performance variable specific enough to measure.',
         },
     }),
-    methodSlot("measurement_method", "How the variable is measured, calculated, or observed.", {
+    methodSlot('measurement_method', 'How the variable is measured, calculated, or observed.', {
         required: false,
         substitutable: false,
-        acceptedEntityTypes: ["method", "calculation", "system", "observation"],
+        acceptedEntityTypes: ['method', 'calculation', 'system', 'observation'],
         diagnostics: {
-            weak: "Clarify how the performance variable is measured.",
+            weak: 'Clarify how the performance variable is measured.',
         },
     }),
-    methodSlot("cadence", "How often the performance variable should be measured or reviewed.", {
+    methodSlot('cadence', 'How often the performance variable should be measured or reviewed.', {
         required: false,
-        acceptedEntityTypes: ["timeframe", "cadence"],
+        acceptedEntityTypes: ['timeframe', 'cadence'],
         diagnostics: {
-            weak: "Clarify how often this variable should be reviewed.",
+            weak: 'Clarify how often this variable should be reviewed.',
         },
     }),
-    methodSlot("threshold", "The trigger, target, tolerance, or threshold used to interpret the variable.", {
+    methodSlot('threshold', 'The trigger, target, tolerance, or threshold used to interpret the variable.', {
         required: false,
-        acceptedEntityTypes: ["threshold", "target", "tolerance", "metric"],
+        acceptedEntityTypes: ['threshold', 'target', 'tolerance', 'metric'],
         diagnostics: {
-            weak: "Clarify the threshold that makes this variable actionable.",
+            weak: 'Clarify the threshold that makes this variable actionable.',
         },
     }),
-    methodSlot("owner_or_source", "The owner, system, dataset, or source responsible for the variable.", {
+    methodSlot('owner_or_source', 'The owner, system, dataset, or source responsible for the variable.', {
         required: false,
         substitutable: false,
-        acceptedEntityTypes: ["owner", "system", "dataset", "source"],
+        acceptedEntityTypes: ['owner', 'system', 'dataset', 'source'],
         diagnostics: {
-            weak: "Clarify who owns or supplies this performance variable.",
+            weak: 'Clarify who owns or supplies this performance variable.',
         },
     }),
 ];
 const capabilitySlots = [
-    methodSlot("capability", "The organizational ability, competency, resource, process, or capacity required to execute the strategy.", {
-        acceptedEntityTypes: ["capability", "competency", "resource", "process", "capacity"],
+    methodSlot('capability', 'The organizational ability, competency, resource, process, or capacity required to execute the strategy.', {
+        acceptedEntityTypes: [
+            'capability',
+            'competency',
+            'resource',
+            'process',
+            'capacity',
+        ],
         diagnostics: {
-            missing: "Identify the capability required to support the strategy.",
-            weak: "Make the capability specific enough to build, assess, or assign.",
+            missing: 'Identify the capability required to support the strategy.',
+            weak: 'Make the capability specific enough to build, assess, or assign.',
         },
     }),
-    methodSlot("capability_purpose", "The strategic purpose or activity the capability enables.", {
+    methodSlot('capability_purpose', 'The strategic purpose or activity the capability enables.', {
         required: false,
-        acceptedEntityTypes: ["purpose", "activity", "solution", "guiding_policy", "outcome"],
+        acceptedEntityTypes: [
+            'purpose',
+            'activity',
+            'solution',
+            'guiding_policy',
+            'outcome',
+        ],
         diagnostics: {
-            weak: "Clarify what strategic purpose this capability serves.",
+            weak: 'Clarify what strategic purpose this capability serves.',
         },
     }),
-    methodSlot("maturity_or_gap", "The current maturity, deficiency, gap, or development need for the capability.", {
+    methodSlot('maturity_or_gap', 'The current maturity, deficiency, gap, or development need for the capability.', {
         required: false,
-        acceptedEntityTypes: ["maturity", "gap", "deficiency", "need"],
+        acceptedEntityTypes: ['maturity', 'gap', 'deficiency', 'need'],
         diagnostics: {
-            weak: "Clarify whether the capability exists, is weak, or needs to be built.",
+            weak: 'Clarify whether the capability exists, is weak, or needs to be built.',
         },
     }),
-    methodSlot("owner_or_location", "The function, team, partner, or part of the organization where the capability lives.", {
+    methodSlot('owner_or_location', 'The function, team, partner, or part of the organization where the capability lives.', {
         required: false,
-        acceptedEntityTypes: ["function", "team", "partner", "organization"],
+        acceptedEntityTypes: ['function', 'team', 'partner', 'organization'],
         diagnostics: {
-            weak: "Clarify where this capability is owned or located.",
+            weak: 'Clarify where this capability is owned or located.',
         },
     }),
 ];
 const systemSlots = [
-    methodSlot("system", "The process, tool, governance mechanism, operating system, data system, or routine that supports the capability.", {
-        acceptedEntityTypes: ["system", "process", "tool", "governance", "routine", "data_system"],
+    methodSlot('system', 'The process, tool, governance mechanism, operating system, data system, or routine that supports the capability.', {
+        acceptedEntityTypes: [
+            'system',
+            'process',
+            'tool',
+            'governance',
+            'routine',
+            'data_system',
+        ],
         diagnostics: {
-            missing: "Identify the system that supports execution.",
-            weak: "Make the system specific enough to design or operate.",
+            missing: 'Identify the system that supports execution.',
+            weak: 'Make the system specific enough to design or operate.',
         },
     }),
-    methodSlot("supported_capability", "The capability, action, or operating need the system supports.", {
+    methodSlot('supported_capability', 'The capability, action, or operating need the system supports.', {
         required: false,
-        acceptedEntityTypes: ["capability", "action", "operation", "need"],
+        acceptedEntityTypes: ['capability', 'action', 'operation', 'need'],
         diagnostics: {
-            weak: "Clarify what capability or operating need this system supports.",
+            weak: 'Clarify what capability or operating need this system supports.',
         },
     }),
-    methodSlot("operating_cadence", "The cadence, trigger, workflow, or operating rhythm for the system.", {
+    methodSlot('operating_cadence', 'The cadence, trigger, workflow, or operating rhythm for the system.', {
         required: false,
-        acceptedEntityTypes: ["cadence", "trigger", "workflow", "timeframe"],
+        acceptedEntityTypes: ['cadence', 'trigger', 'workflow', 'timeframe'],
         diagnostics: {
-            weak: "Clarify how or when the system operates.",
+            weak: 'Clarify how or when the system operates.',
         },
     }),
-    methodSlot("control_or_feedback", "The control, feedback loop, metric, or governance signal used by the system.", {
+    methodSlot('control_or_feedback', 'The control, feedback loop, metric, or governance signal used by the system.', {
         required: false,
-        acceptedEntityTypes: ["control", "feedback", "metric", "governance"],
+        acceptedEntityTypes: ['control', 'feedback', 'metric', 'governance'],
         diagnostics: {
-            weak: "Clarify how the system controls or learns from performance.",
+            weak: 'Clarify how the system controls or learns from performance.',
         },
     }),
 ];
 const principleSlots = [
-    methodSlot("principle", "The durable rule, standard, belief, or operating doctrine that should guide decisions.", {
-        acceptedEntityTypes: ["principle", "standard", "belief", "doctrine", "rule"],
+    methodSlot('principle', 'The durable rule, standard, belief, or operating doctrine that should guide decisions.', {
+        acceptedEntityTypes: [
+            'principle',
+            'standard',
+            'belief',
+            'doctrine',
+            'rule',
+        ],
         diagnostics: {
-            missing: "State the principle that should guide decisions.",
-            weak: "Make the principle specific enough to constrain choices.",
+            missing: 'State the principle that should guide decisions.',
+            weak: 'Make the principle specific enough to constrain choices.',
         },
     }),
-    methodSlot("decision_context", "The decision, behavior, system, team, or tradeoff the principle governs.", {
+    methodSlot('decision_context', 'The decision, behavior, system, team, or tradeoff the principle governs.', {
         required: false,
-        acceptedEntityTypes: ["decision", "behavior", "system", "team", "tradeoff"],
+        acceptedEntityTypes: [
+            'decision',
+            'behavior',
+            'system',
+            'team',
+            'tradeoff',
+        ],
         diagnostics: {
-            weak: "Clarify what context this principle governs.",
+            weak: 'Clarify what context this principle governs.',
         },
     }),
-    methodSlot("priority_or_tradeoff", "The priority, tradeoff, or preference implied by the principle.", {
+    methodSlot('priority_or_tradeoff', 'The priority, tradeoff, or preference implied by the principle.', {
         required: false,
-        acceptedEntityTypes: ["priority", "tradeoff", "preference"],
+        acceptedEntityTypes: ['priority', 'tradeoff', 'preference'],
         diagnostics: {
-            weak: "Clarify what this principle prioritizes or rules out.",
+            weak: 'Clarify what this principle prioritizes or rules out.',
         },
     }),
-    methodSlot("exception_condition", "The condition under which the principle may not apply.", {
+    methodSlot('exception_condition', 'The condition under which the principle may not apply.', {
         required: false,
-        acceptedEntityTypes: ["condition", "exception", "constraint"],
+        acceptedEntityTypes: ['condition', 'exception', 'constraint'],
         diagnostics: {
-            weak: "Clarify exceptions if the principle is not universal.",
+            weak: 'Clarify exceptions if the principle is not universal.',
         },
     }),
 ];
@@ -737,26 +948,27 @@ function element(position, type, component, expectedMood, examples, options = {}
         position,
         expectedMood,
         syntacticSlots: options.syntacticSlots ??
-            (expectedMood === "imperative"
+            (expectedMood === 'imperative'
                 ? imperativeSyntax
-                : expectedMood === "noun_phrase"
+                : expectedMood === 'noun_phrase'
                     ? nounPhraseSyntax
                     : indicativeSyntax),
         methodSlots: options.methodSlots ??
-            (expectedMood === "imperative" || expectedMood === "noun_phrase"
+            (expectedMood === 'imperative' || expectedMood === 'noun_phrase'
                 ? imperativeMethodSlots
                 : indicativeMethodSlots),
         examples,
         rules: {
             examplesRequired: options.rules?.examplesRequired ?? true,
             minimumRequiredSlots: options.rules?.minimumRequiredSlots ??
-                (options.methodSlots ?? (expectedMood === "imperative" || expectedMood === "noun_phrase"
-                    ? imperativeMethodSlots
-                    : indicativeMethodSlots)).filter((slot) => slot.required).length,
+                (options.methodSlots ??
+                    (expectedMood === 'imperative' || expectedMood === 'noun_phrase'
+                        ? imperativeMethodSlots
+                        : indicativeMethodSlots)).filter((slot) => slot.required).length,
             allowInference: options.rules?.allowInference ?? false,
             diagnostics: {
                 wrongMood: options.rules?.diagnostics?.wrongMood ??
-                    `${schemaElement.label} should be written in ${expectedMood.replace("_", " ")} mood.`,
+                    `${schemaElement.label} should be written in ${expectedMood.replace('_', ' ')} mood.`,
                 insufficient: options.rules?.diagnostics?.insufficient ??
                     `${schemaElement.label} does not yet contain enough method substance.`,
                 missing: options.rules?.diagnostics?.missing ??
@@ -814,304 +1026,311 @@ function elementPositionInSchema(type) {
         const index = elements.findIndex((element) => element.value === type);
         if (index === -1)
             continue;
-        return (componentPosition.get(component) ?? 0) * 100 + index;
+        return ((componentPosition.get(component) ??
+            0) *
+            100 +
+            index);
     }
     return 9999;
 }
 export const elementDefinitions = [
-    element(elementPositionInSchema("key_challenge"), "key_challenge", "diagnosis", "indicative", [
-        "Anti-competition laws in Australia hinder the ability to grow through acquisitions.",
+    element(elementPositionInSchema('key_challenge'), 'key_challenge', 'diagnosis', 'indicative', [
+        'Anti-competition laws in Australia hinder the ability to grow through acquisitions.',
     ], {
         methodSlots: keyChallengeSlots,
         rules: {
             minimumRequiredSlots: 3,
             diagnostics: {
-                insufficient: "A key challenge must identify who is facing the challenge, what pressure is creating it, and why it matters.",
+                insufficient: 'A key challenge must identify who is facing the challenge, what pressure is creating it, and why it matters.',
             },
         },
     }),
-    element(elementPositionInSchema("supporting_fact"), "supporting_fact", "diagnosis", "indicative", [
-        "Q1 FY24 sales reached $1.5M, 18% below the prior year.",
-        "Foot traffic declined 12% across metropolitan stores over the past two quarters.",
+    element(elementPositionInSchema('supporting_fact'), 'supporting_fact', 'diagnosis', 'indicative', [
+        'Q1 FY24 sales reached $1.5M, 18% below the prior year.',
+        'Foot traffic declined 12% across metropolitan stores over the past two quarters.',
     ], {
         methodSlots: supportingFactSlots,
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "A supporting fact must identify what is being measured or observed and state the evidence clearly.",
+                insufficient: 'A supporting fact must identify what is being measured or observed and state the evidence clearly.',
             },
         },
     }),
-    element(elementPositionInSchema("impact"), "impact", "diagnosis", "indicative", [
-        "Employee turnover rates increase substantially when aggressive price competition limits earnings potential for sales personnel dependent on commission-based income.",
-        "Interest rate adjustments accelerate the depreciation of inventory holdings, reducing the collateral value available for securing additional floor plan financing.",
-        "Customer acquisition costs may remain high due to high percentage of offline media spend.",
+    element(elementPositionInSchema('impact'), 'impact', 'diagnosis', 'indicative', [
+        'Employee turnover rates increase substantially when aggressive price competition limits earnings potential for sales personnel dependent on commission-based income.',
+        'Interest rate adjustments accelerate the depreciation of inventory holdings, reducing the collateral value available for securing additional floor plan financing.',
+        'Customer acquisition costs may remain high due to high percentage of offline media spend.',
     ], {
-        aliases: ["associated_impact"],
+        aliases: ['associated_impact'],
         methodSlots: impactSlots,
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "An impact must identify what is affected and explain how the challenge creates that effect.",
+                insufficient: 'An impact must identify what is affected and explain how the challenge creates that effect.',
             },
         },
     }),
-    element(elementPositionInSchema("guiding_policy"), "guiding_policy", "method", "imperative", [
-        "Use dynamically adjusted prices during off-peak periods.",
-        "Shift down market to lower priced goods.",
-        "Focus on secondary sale periods.",
-        "Use network effects to expand our audience and identify new customer segments.",
+    element(elementPositionInSchema('guiding_policy'), 'guiding_policy', 'method', 'imperative', [
+        'Use dynamically adjusted prices during off-peak periods.',
+        'Shift down market to lower priced goods.',
+        'Focus on secondary sale periods.',
+        'Use network effects to expand our audience and identify new customer segments.',
     ], {
         methodSlots: guidingPolicySlots,
         allowedEntityTypes: [
-            "Category",
-            "Segment",
-            "Geography",
-            "Channel",
-            "Function",
-            "Cost",
-            "Labour",
-            "Approach",
-            "Method",
-            "Move",
-            "Position",
-            "Instrument",
-            "Source of Advantage",
-            "Resource",
-            "Other",
+            'Category',
+            'Segment',
+            'Geography',
+            'Channel',
+            'Function',
+            'Cost',
+            'Labour',
+            'Approach',
+            'Method',
+            'Move',
+            'Position',
+            'Instrument',
+            'Source of Advantage',
+            'Resource',
+            'Other',
         ],
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "A guiding policy must state a strategic action and the object it acts on.",
+                insufficient: 'A guiding policy must state a strategic action and the object it acts on.',
             },
         },
     }),
-    element(elementPositionInSchema("competitor_move"), "competitor_move", "method", "indicative", [
-        "Competitors will reduce stock levels at similar rates to maintain lower inventory costs.",
-        "Google may impose restrictions on third-party applications, making access to distribution channels more difficult.",
+    element(elementPositionInSchema('competitor_move'), 'competitor_move', 'method', 'indicative', [
+        'Competitors will reduce stock levels at similar rates to maintain lower inventory costs.',
+        'Google may impose restrictions on third-party applications, making access to distribution channels more difficult.',
     ], {
         methodSlots: competitorMoveSlots,
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "A competitor move must identify the actor making the move and the move being made.",
+                insufficient: 'A competitor move must identify the actor making the move and the move being made.',
             },
         },
     }),
-    element(elementPositionInSchema("scope"), "scope", "method", "imperative", [
-        "Open new stores in Australia and New Zealand.",
-        "Target women 25-45 years old.",
-        "Prioritize API-driven integrations with enterprise resource planning platforms.",
+    element(elementPositionInSchema('scope'), 'scope', 'method', 'imperative', [
+        'Open new stores in Australia and New Zealand.',
+        'Target women 25-45 years old.',
+        'Prioritize API-driven integrations with enterprise resource planning platforms.',
     ], {
         methodSlots: scopeSlots,
-        allowedEntityTypes: ["Audience", "Market", "Category", "Product", "Service", "Vertical Stage", "Other"],
+        allowedEntityTypes: [
+            'Audience',
+            'Market',
+            'Category',
+            'Product',
+            'Service',
+            'Vertical Stage',
+            'Other',
+        ],
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "A scope element must define what is included, excluded, or bounded.",
+                insufficient: 'A scope element must define what is included, excluded, or bounded.',
             },
         },
     }),
-    element(elementPositionInSchema("constraint"), "constraint", "method", "indicative", [
-        "Differences in advertising regulations across geographic regions means some campaigns cannot be replicated.",
-        "Production line volumes cannot exceed 2,000 units per day.",
+    element(elementPositionInSchema('constraint'), 'constraint', 'method', 'indicative', [
+        'Differences in advertising regulations across geographic regions means some campaigns cannot be replicated.',
+        'Production line volumes cannot exceed 2,000 units per day.',
     ], {
         methodSlots: constraintSlots,
         allowedEntityTypes: [
-            "internal",
-            "externality",
-            "fiscal",
-            "regulatory",
-            "competitive",
-            "technological",
-            "environmental",
-            "social",
-            "temporal",
-            "other",
+            'internal',
+            'externality',
+            'fiscal',
+            'regulatory',
+            'competitive',
+            'technological',
+            'environmental',
+            'social',
+            'temporal',
+            'other',
         ],
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "A constraint must identify the source of the limitation and the limitation it imposes.",
+                insufficient: 'A constraint must identify the source of the limitation and the limitation it imposes.',
             },
         },
     }),
-    element(elementPositionInSchema("solution"), "solution", "initiatives", "noun_phrase", [
-        "Remove poor profit margin products.",
-        "Exit the Australian market.",
-        "Divest Catch of the Day and seek to acquire major global brand.",
+    element(elementPositionInSchema('solution'), 'solution', 'initiatives', 'noun_phrase', [
+        'Remove poor profit margin products.',
+        'Exit the Australian market.',
+        'Divest Catch of the Day and seek to acquire major global brand.',
     ], {
-        aliases: ["solution_alternative"],
+        aliases: ['solution_alternative'],
         methodSlots: solutionSlots,
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "A solution must identify the strategic option or intervention being considered.",
+                insufficient: 'A solution must identify the strategic option or intervention being considered.',
             },
         },
     }),
-    element(elementPositionInSchema("assumption_hypothesis"), "assumption_hypothesis", "initiatives", "indicative", [
-        "Younger women are willing to pay a premium for prestige-like products sold through traditional mass channels.",
-        "Price reductions improve sales growth if increased customer transaction volume offsets a reduction in average spend.",
+    element(elementPositionInSchema('assumption_hypothesis'), 'assumption_hypothesis', 'initiatives', 'indicative', [
+        'Younger women are willing to pay a premium for prestige-like products sold through traditional mass channels.',
+        'Price reductions improve sales growth if increased customer transaction volume offsets a reduction in average spend.',
     ], {
         methodSlots: assumptionHypothesisSlots,
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "An assumption hypothesis must state the belief or condition that needs to be true.",
+                insufficient: 'An assumption hypothesis must state the belief or condition that needs to be true.',
             },
         },
     }),
-    element(elementPositionInSchema("experiment"), "experiment", "initiatives", "imperative", [
-        "Conduct a market test by launching a limited edition prestige-like Olay product in select mass channels.",
-        "Model scenario with 4, 6, and 8 year projections.",
+    element(elementPositionInSchema('experiment'), 'experiment', 'initiatives', 'imperative', [
+        'Conduct a market test by launching a limited edition prestige-like Olay product in select mass channels.',
+        'Model scenario with 4, 6, and 8 year projections.',
     ], {
         methodSlots: experimentSlots,
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "An experiment must state the test action to perform.",
+                insufficient: 'An experiment must state the test action to perform.',
             },
         },
     }),
-    element(elementPositionInSchema("action"), "action", "initiatives", "imperative", [
-        "Collaborate with retail partners to create a masstige in-store experience for Olay products.",
-        "Identify 10 new stores based on site selection analysis.",
+    element(elementPositionInSchema('action'), 'action', 'initiatives', 'imperative', [
+        'Collaborate with retail partners to create a masstige in-store experience for Olay products.',
+        'Identify 10 new stores based on site selection analysis.',
     ], {
         methodSlots: actionSlots,
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "An action must state the concrete task, decision, or implementation step to perform.",
+                insufficient: 'An action must state the concrete task, decision, or implementation step to perform.',
             },
         },
     }),
-    element(elementPositionInSchema("investment"), "investment", "initiatives", "noun_phrase", ["Return on Invested Capital."], {
+    element(elementPositionInSchema('investment'), 'investment', 'initiatives', 'noun_phrase', ['Return on Invested Capital.'], {
         methodSlots: investmentSlots,
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "An investment must identify the commitment amount and what is being invested in.",
+                insufficient: 'An investment must identify the commitment amount and what is being invested in.',
             },
         },
     }),
-    element(elementPositionInSchema("estimate"), "estimate", "initiatives", "indicative", [
-        "500,000 new sales in first half.",
-        "Incremental 1% gain in soft goods market share equals a $34m revenue opportunity.",
+    element(elementPositionInSchema('estimate'), 'estimate', 'initiatives', 'indicative', [
+        '500,000 new sales in first half.',
+        'Incremental 1% gain in soft goods market share equals a $34m revenue opportunity.',
     ], {
         methodSlots: estimateSlots,
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "An estimate must state what is being estimated and the estimated amount or range.",
+                insufficient: 'An estimate must state what is being estimated and the estimated amount or range.',
             },
         },
     }),
-    element(elementPositionInSchema("baseline"), "baseline", "measures", "indicative", [
-        "Q1 FY24 sales reached $1.5M.",
-        "5,000 SKUs have a profit margin below 25%.",
+    element(elementPositionInSchema('baseline'), 'baseline', 'measures', 'indicative', [
+        'Q1 FY24 sales reached $1.5M.',
+        '5,000 SKUs have a profit margin below 25%.',
     ], {
         methodSlots: baselineSlots,
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "A baseline must identify what is measured and the starting value or condition.",
+                insufficient: 'A baseline must identify what is measured and the starting value or condition.',
             },
         },
     }),
-    element(elementPositionInSchema("outcome"), "outcome", "measures", "noun_phrase", [
-        "$2 million revenue by 2025.",
-        "Total sales for Q3 FY25 to exceed $1.6M.",
-    ], {
+    element(elementPositionInSchema('outcome'), 'outcome', 'measures', 'noun_phrase', ['$2 million revenue by 2025.', 'Total sales for Q3 FY25 to exceed $1.6M.'], {
         methodSlots: outcomeSlots,
         rules: {
             minimumRequiredSlots: 2,
             diagnostics: {
-                insufficient: "An outcome must identify the target object and the desired value or state.",
+                insufficient: 'An outcome must identify the target object and the desired value or state.',
             },
         },
     }),
-    element(elementPositionInSchema("performance_variable"), "performance_variable", "measures", "noun_phrase", [
-        "Average number of units sold per retailer.",
-        "Weekly foot traffic exceeds 500.",
+    element(elementPositionInSchema('performance_variable'), 'performance_variable', 'measures', 'noun_phrase', [
+        'Average number of units sold per retailer.',
+        'Weekly foot traffic exceeds 500.',
     ], {
         methodSlots: performanceVariableSlots,
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "A performance variable must identify the metric or indicator to track.",
+                insufficient: 'A performance variable must identify the metric or indicator to track.',
             },
         },
     }),
-    element(elementPositionInSchema("capability"), "capability", "support", "noun_phrase", [
-        "Inventory management: hold less stock and replenish on demand.",
-        "Strategic site selection analysis with GIS competency.",
+    element(elementPositionInSchema('capability'), 'capability', 'support', 'noun_phrase', [
+        'Inventory management: hold less stock and replenish on demand.',
+        'Strategic site selection analysis with GIS competency.',
     ], {
         methodSlots: capabilitySlots,
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "A capability must identify the organizational ability required to support the strategy.",
+                insufficient: 'A capability must identify the organizational ability required to support the strategy.',
             },
         },
     }),
-    element(elementPositionInSchema("system"), "system", "support", "noun_phrase", [
-        "Implementation of a strategic sales management system focusing on high margin products.",
-        "Daily store foot traffic analysis.",
+    element(elementPositionInSchema('system'), 'system', 'support', 'noun_phrase', [
+        'Implementation of a strategic sales management system focusing on high margin products.',
+        'Daily store foot traffic analysis.',
     ], {
         methodSlots: systemSlots,
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "A system must identify the process, tool, governance mechanism, or routine that supports execution.",
+                insufficient: 'A system must identify the process, tool, governance mechanism, or routine that supports execution.',
             },
         },
     }),
-    element(elementPositionInSchema("principle"), "principle", "support", "imperative", [
-        "Prioritize domestic market before considering international expansion.",
-        "Put the customer first.",
+    element(elementPositionInSchema('principle'), 'principle', 'support', 'imperative', [
+        'Prioritize domestic market before considering international expansion.',
+        'Put the customer first.',
     ], {
         methodSlots: principleSlots,
         rules: {
             minimumRequiredSlots: 1,
             diagnostics: {
-                insufficient: "A principle must state the durable rule or standard that should guide decisions.",
+                insufficient: 'A principle must state the durable rule or standard that should guide decisions.',
             },
         },
     }),
 ];
 export const elementRelationshipDefinitions = [
-    relationship("key_challenge", "supporting_fact", "EVIDENCED_BY", "Evidenced By", "A key challenge is evidenced by supporting facts."),
-    relationship("key_challenge", "impact", "CAUSES", "Causes", "A key challenge causes or contributes to an impact."),
-    relationship("key_challenge", "guiding_policy", "ADDRESSED_BY", "Addressed By", "A key challenge is addressed by a guiding policy.", {
-        cardinality: "one_or_more",
+    relationship('key_challenge', 'supporting_fact', 'EVIDENCED_BY', 'Evidenced By', 'A key challenge is evidenced by supporting facts.'),
+    relationship('key_challenge', 'impact', 'CAUSES', 'Causes', 'A key challenge causes or contributes to an impact.'),
+    relationship('key_challenge', 'guiding_policy', 'ADDRESSED_BY', 'Addressed By', 'A key challenge is addressed by a guiding policy.', {
+        cardinality: 'one_or_more',
         requiredForCompleteness: true,
         diagnostics: {
-            missing: "Link the key challenge to at least one guiding policy.",
+            missing: 'Link the key challenge to at least one guiding policy.',
         },
     }),
-    relationship("scope", "guiding_policy", "LIMITS", "Limits", "Scope limits the guiding policy."),
-    relationship("constraint", "guiding_policy", "CONSTRAINS", "Constrains", "A constraint narrows or restricts a guiding policy."),
-    relationship("competitor_move", "key_challenge", "THREATENS", "Threatens", "A competitor move can threaten or intensify a key challenge."),
-    relationship("guiding_policy", "solution", "IMPLEMENTED_VIA", "Implemented Via", "A guiding policy is implemented through solutions.", {
-        cardinality: "one_or_more",
+    relationship('scope', 'guiding_policy', 'LIMITS', 'Limits', 'Scope limits the guiding policy.'),
+    relationship('constraint', 'guiding_policy', 'CONSTRAINS', 'Constrains', 'A constraint narrows or restricts a guiding policy.'),
+    relationship('competitor_move', 'key_challenge', 'THREATENS', 'Threatens', 'A competitor move can threaten or intensify a key challenge.'),
+    relationship('guiding_policy', 'solution', 'IMPLEMENTED_VIA', 'Implemented Via', 'A guiding policy is implemented through solutions.', {
+        cardinality: 'one_or_more',
         requiredForCompleteness: true,
         diagnostics: {
-            missing: "Link the guiding policy to at least one solution.",
-        },
-    }),
-    relationship("constraint", "solution", "CONSTRAINS", "Constrains", "A constraint limits a solution."),
-    relationship("solution", "assumption_hypothesis", "VALIDATED_BY", "Validated By", "A solution is validated by assumptions or hypotheses."),
-    relationship("assumption_hypothesis", "experiment", "TESTED_BY", "Tested By", "An assumption or hypothesis is tested by an experiment."),
-    relationship("experiment", "action", "PRODUCES", "Produces", "An experiment produces actions or evidence for action."),
-    relationship("solution", "investment", "REQUIRES_INVESTMENT", "Requires Investment", "A solution requires investment."),
-    relationship("solution", "estimate", "ESTIMATED_AT", "Estimated At", "A solution is estimated by an estimate."),
-    relationship("solution", "outcome", "TARGETS", "Targets", "A solution targets an outcome."),
-    relationship("baseline", "outcome", "COMPARED_TO", "Compared To", "A baseline is compared to an outcome."),
-    relationship("outcome", "performance_variable", "MEASURED_BY", "Measured By", "An outcome is measured by performance variables."),
-    relationship("solution", "capability", "REQUIRES_CAPABILITY", "Requires Capability", "A solution requires capabilities."),
-    relationship("capability", "system", "SUPPORTED_BY", "Supported By", "A capability is supported by systems."),
-    relationship("system", "principle", "GOVERNED_BY", "Governed By", "A system is governed by principles."),
+            missing: 'Link the guiding policy to at least one solution.',
+        },
+    }),
+    relationship('constraint', 'solution', 'CONSTRAINS', 'Constrains', 'A constraint limits a solution.'),
+    relationship('solution', 'assumption_hypothesis', 'VALIDATED_BY', 'Validated By', 'A solution is validated by assumptions or hypotheses.'),
+    relationship('assumption_hypothesis', 'experiment', 'TESTED_BY', 'Tested By', 'An assumption or hypothesis is tested by an experiment.'),
+    relationship('experiment', 'action', 'PRODUCES', 'Produces', 'An experiment produces actions or evidence for action.'),
+    relationship('solution', 'investment', 'REQUIRES_INVESTMENT', 'Requires Investment', 'A solution requires investment.'),
+    relationship('solution', 'estimate', 'ESTIMATED_AT', 'Estimated At', 'A solution is estimated by an estimate.'),
+    relationship('solution', 'outcome', 'TARGETS', 'Targets', 'A solution targets an outcome.'),
+    relationship('baseline', 'outcome', 'COMPARED_TO', 'Compared To', 'A baseline is compared to an outcome.'),
+    relationship('outcome', 'performance_variable', 'MEASURED_BY', 'Measured By', 'An outcome is measured by performance variables.'),
+    relationship('solution', 'capability', 'REQUIRES_CAPABILITY', 'Requires Capability', 'A solution requires capabilities.'),
+    relationship('capability', 'system', 'SUPPORTED_BY', 'Supported By', 'A capability is supported by systems.'),
+    relationship('system', 'principle', 'GOVERNED_BY', 'Governed By', 'A system is governed by principles.'),
 ];
-//# sourceMappingURL=definitions.js.map