@skhema/method 0.1.0

package/dist/definitions.js

@@ -0,0 +1,1117 @@
+import { COMPONENT_TYPES, ELEMENT_TYPES, SKHEMA_MAPPING, } from "@skhema/types/schema";
+function titleCase(value) {
+    return value
+        .split("_")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function syntacticSlot(id, description, required = true) {
+    return { id, label: titleCase(id), description, required };
+}
+function methodSlot(id, description, options = {}) {
+    const required = options.required ?? true;
+    const slotLabel = titleCase(id);
+    const definition = {
+        id,
+        label: slotLabel,
+        description,
+        required,
+        substitutable: options.substitutable ?? true,
+        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"),
+        acceptedEntityTypes: options.acceptedEntityTypes ?? [],
+        diagnostics: options.diagnostics ?? {
+            ...(required ? { missing: `${slotLabel} is required.` } : {}),
+            weak: `${slotLabel} needs clearer method substance.`,
+        },
+    };
+    if (options.examples) {
+        definition.examples = options.examples;
+    }
+    return definition;
+}
+function relationship(source, target, type, label, description, options = {}) {
+    return {
+        source,
+        target,
+        type,
+        label,
+        description,
+        cardinality: options.cardinality ?? "zero_or_more",
+        requiredForCompleteness: options.requiredForCompleteness ?? false,
+        evidence: options.evidence ?? "semantic_alignment",
+        scope: options.scope ?? ["same_strategy", "same_workspace"],
+        diagnostics: options.diagnostics ?? {
+            ...(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),
+];
+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),
+];
+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),
+];
+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.", {
+        required: false,
+        examples: ["in the next 12 months", "by 2030", "in Q2 2025"],
+    }),
+];
+const imperativeMethodSlots = [
+    methodSlot("relative_clause", "Relative clause that modifies the noun phrase.", {
+        required: false,
+    }),
+    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"],
+        diagnostics: {
+            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",
+        acceptedEntityTypes: [
+            "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.",
+        },
+    }),
+    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.",
+        },
+    }),
+    methodSlot("industry_context", "The industry or sector context, if present.", {
+        required: false,
+        acceptedEntityTypes: ["industry"],
+        diagnostics: {
+            weak: "Clarify the industry context if it changes the nature of the challenge.",
+        },
+    }),
+    methodSlot("geographic_context", "The location, market, or region context, if present.", {
+        required: false,
+        acceptedEntityTypes: ["geo", "market"],
+        diagnostics: {
+            weak: "Clarify geography if the challenge depends on location or market boundaries.",
+        },
+    }),
+    methodSlot("temporal_context", "The timeframe, deadline, period, or timing assumption, if present.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            weak: "Clarify timing if urgency or sequencing affects the strategic response.",
+        },
+    }),
+    methodSlot("constraint", "A limiting condition, dependency, or tradeoff that narrows the challenge.", {
+        required: false,
+        acceptedEntityTypes: ["constraint", "dependency", "tradeoff"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["decision", "resource", "capability", "strategic_object"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["trend", "comparison", "directional_change"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            weak: "Clarify the time period for the supporting fact.",
+        },
+    }),
+    methodSlot("source_context", "The source, basis, or measurement context for the fact.", {
+        required: false,
+        substitutable: false,
+        acceptedEntityTypes: ["source", "dataset", "report", "experiment"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["metric", "risk", "severity", "estimate"],
+        diagnostics: {
+            weak: "Clarify the scale or materiality of the impact if known.",
+        },
+    }),
+    methodSlot("temporal_context", "The timeframe over which the impact occurs or becomes material.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            weak: "Clarify when the impact occurs or becomes material.",
+        },
+    }),
+    methodSlot("downstream_consequence", "The further strategic consequence created by the immediate impact.", {
+        required: false,
+        acceptedEntityTypes: ["consequence", "risk", "outcome"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["advantage", "capability", "mechanism", "tradeoff"],
+        diagnostics: {
+            weak: "Clarify why this policy is expected to work.",
+        },
+    }),
+    methodSlot("boundary", "The explicit limit, exclusion, or tradeoff implied by the policy.", {
+        required: false,
+        acceptedEntityTypes: ["scope", "constraint", "tradeoff"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["threat", "pressure", "advantage", "risk"],
+        diagnostics: {
+            weak: "Clarify why this competitor move is strategically relevant.",
+        },
+    }),
+    methodSlot("temporal_context", "The timeframe in which the move is occurring or expected.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["action", "priority", "boundary"],
+        diagnostics: {
+            weak: "Clarify the action implied by the scope statement.",
+        },
+    }),
+    methodSlot("excluded_domain", "The domain explicitly excluded or deprioritized by the scope.", {
+        required: false,
+        acceptedEntityTypes: ["market", "segment", "geo", "category", "product", "service", "channel", "activity"],
+        diagnostics: {
+            weak: "Clarify what is outside scope if the boundary matters.",
+        },
+    }),
+    methodSlot("boundary_condition", "The threshold, condition, or criterion that defines the scope boundary.", {
+        required: false,
+        acceptedEntityTypes: ["metric", "threshold", "condition", "criterion"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["guiding_policy", "solution", "action", "investment", "capability"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["constraint_type"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["mechanism", "capability", "process", "advantage"],
+        diagnostics: {
+            weak: "Clarify how this solution is expected to work.",
+        },
+    }),
+    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"],
+        diagnostics: {
+            weak: "Clarify the context or target for the solution.",
+        },
+    }),
+    methodSlot("tradeoff", "The sacrifice, exclusion, cost, or risk implied by choosing this solution.", {
+        required: false,
+        acceptedEntityTypes: ["tradeoff", "cost", "risk", "constraint"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["outcome", "behavior", "metric", "result"],
+        diagnostics: {
+            weak: "Clarify what outcome depends on this assumption.",
+        },
+    }),
+    methodSlot("test_condition", "The observable condition or evidence that would confirm or disconfirm the assumption.", {
+        required: false,
+        acceptedEntityTypes: ["evidence", "metric", "threshold", "condition"],
+        diagnostics: {
+            weak: "Clarify how this assumption could be tested.",
+        },
+    }),
+    methodSlot("timeframe", "The period over which the assumption should hold or be tested.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["assumption_hypothesis", "uncertainty", "belief"],
+        diagnostics: {
+            weak: "Clarify what assumption or uncertainty this experiment tests.",
+        },
+    }),
+    methodSlot("success_metric", "The metric, threshold, or evidence that determines the result of the experiment.", {
+        required: false,
+        acceptedEntityTypes: ["metric", "threshold", "evidence"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["segment", "sample", "geo", "product", "scope"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["person", "team", "function", "partner", "organization"],
+        diagnostics: {
+            weak: "Clarify who owns or performs the action.",
+        },
+    }),
+    methodSlot("target_object", "The process, product, customer, system, resource, or activity the action changes.", {
+        required: false,
+        acceptedEntityTypes: ["process", "product", "customer", "system", "resource", "activity"],
+        diagnostics: {
+            weak: "Clarify what the action changes.",
+        },
+    }),
+    methodSlot("timeframe", "The deadline, cadence, or timing of the action.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            weak: "Clarify the investment period.",
+        },
+    }),
+];
+const estimateSlots = [
+    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.",
+        },
+    }),
+    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.",
+        },
+    }),
+    methodSlot("estimate_period", "The timeframe or period for the estimate.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            weak: "Clarify the estimate period.",
+        },
+    }),
+    methodSlot("basis", "The assumption, experiment, benchmark, or source that supports the estimate.", {
+        required: false,
+        substitutable: false,
+        acceptedEntityTypes: ["assumption_hypothesis", "experiment", "benchmark", "source"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            weak: "Clarify the measurement period 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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["benchmark", "prior_period", "reference_point", "comparison"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe"],
+        diagnostics: {
+            weak: "Clarify when the outcome should be achieved.",
+        },
+    }),
+    methodSlot("success_condition", "The condition under which the outcome should be considered achieved.", {
+        required: false,
+        acceptedEntityTypes: ["condition", "threshold", "metric"],
+        diagnostics: {
+            weak: "Clarify what would count as success.",
+        },
+    }),
+    methodSlot("strategic_effect", "The strategic effect or business consequence expected if the outcome is achieved.", {
+        required: false,
+        acceptedEntityTypes: ["effect", "consequence", "advantage", "impact"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        substitutable: false,
+        acceptedEntityTypes: ["method", "calculation", "system", "observation"],
+        diagnostics: {
+            weak: "Clarify how the performance variable is measured.",
+        },
+    }),
+    methodSlot("cadence", "How often the performance variable should be measured or reviewed.", {
+        required: false,
+        acceptedEntityTypes: ["timeframe", "cadence"],
+        diagnostics: {
+            weak: "Clarify how often this variable should be reviewed.",
+        },
+    }),
+    methodSlot("threshold", "The trigger, target, tolerance, or threshold used to interpret the variable.", {
+        required: false,
+        acceptedEntityTypes: ["threshold", "target", "tolerance", "metric"],
+        diagnostics: {
+            weak: "Clarify the threshold that makes this variable actionable.",
+        },
+    }),
+    methodSlot("owner_or_source", "The owner, system, dataset, or source responsible for the variable.", {
+        required: false,
+        substitutable: false,
+        acceptedEntityTypes: ["owner", "system", "dataset", "source"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["purpose", "activity", "solution", "guiding_policy", "outcome"],
+        diagnostics: {
+            weak: "Clarify what strategic purpose this capability serves.",
+        },
+    }),
+    methodSlot("maturity_or_gap", "The current maturity, deficiency, gap, or development need for the capability.", {
+        required: false,
+        acceptedEntityTypes: ["maturity", "gap", "deficiency", "need"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["function", "team", "partner", "organization"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["capability", "action", "operation", "need"],
+        diagnostics: {
+            weak: "Clarify what capability or operating need this system supports.",
+        },
+    }),
+    methodSlot("operating_cadence", "The cadence, trigger, workflow, or operating rhythm for the system.", {
+        required: false,
+        acceptedEntityTypes: ["cadence", "trigger", "workflow", "timeframe"],
+        diagnostics: {
+            weak: "Clarify how or when the system operates.",
+        },
+    }),
+    methodSlot("control_or_feedback", "The control, feedback loop, metric, or governance signal used by the system.", {
+        required: false,
+        acceptedEntityTypes: ["control", "feedback", "metric", "governance"],
+        diagnostics: {
+            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"],
+        diagnostics: {
+            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.", {
+        required: false,
+        acceptedEntityTypes: ["decision", "behavior", "system", "team", "tradeoff"],
+        diagnostics: {
+            weak: "Clarify what context this principle governs.",
+        },
+    }),
+    methodSlot("priority_or_tradeoff", "The priority, tradeoff, or preference implied by the principle.", {
+        required: false,
+        acceptedEntityTypes: ["priority", "tradeoff", "preference"],
+        diagnostics: {
+            weak: "Clarify what this principle prioritizes or rules out.",
+        },
+    }),
+    methodSlot("exception_condition", "The condition under which the principle may not apply.", {
+        required: false,
+        acceptedEntityTypes: ["condition", "exception", "constraint"],
+        diagnostics: {
+            weak: "Clarify exceptions if the principle is not universal.",
+        },
+    }),
+];
+function element(position, type, component, expectedMood, examples, options = {}) {
+    const schemaElement = Object.values(ELEMENT_TYPES).find((candidate) => candidate.value === type);
+    if (!schemaElement) {
+        throw new Error(`Unknown canonical element type: ${type}`);
+    }
+    const definition = {
+        type,
+        label: schemaElement.label,
+        acronym: schemaElement.acronym,
+        component,
+        position,
+        expectedMood,
+        syntacticSlots: options.syntacticSlots ??
+            (expectedMood === "imperative"
+                ? imperativeSyntax
+                : expectedMood === "noun_phrase"
+                    ? nounPhraseSyntax
+                    : indicativeSyntax),
+        methodSlots: options.methodSlots ??
+            (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,
+            allowInference: options.rules?.allowInference ?? false,
+            diagnostics: {
+                wrongMood: options.rules?.diagnostics?.wrongMood ??
+                    `${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 ??
+                    `${schemaElement.label} is missing required method substance.`,
+                weak: options.rules?.diagnostics?.weak ??
+                    `${schemaElement.label} needs sharper method substance.`,
+                invalid: options.rules?.diagnostics?.invalid ??
+                    `${schemaElement.label} does not match its method definition.`,
+            },
+        },
+    };
+    if (options.aliases) {
+        definition.aliases = options.aliases;
+    }
+    if (options.allowedEntityTypes) {
+        definition.allowedEntityTypes = options.allowedEntityTypes;
+    }
+    return definition;
+}
+export const componentDefinitions = [
+    {
+        type: COMPONENT_TYPES.DIAGNOSIS.value,
+        label: COMPONENT_TYPES.DIAGNOSIS.label,
+        acronym: COMPONENT_TYPES.DIAGNOSIS.acronym,
+        position: 1,
+    },
+    {
+        type: COMPONENT_TYPES.METHOD.value,
+        label: COMPONENT_TYPES.METHOD.label,
+        acronym: COMPONENT_TYPES.METHOD.acronym,
+        position: 2,
+    },
+    {
+        type: COMPONENT_TYPES.INITIATIVES.value,
+        label: COMPONENT_TYPES.INITIATIVES.label,
+        acronym: COMPONENT_TYPES.INITIATIVES.acronym,
+        position: 3,
+    },
+    {
+        type: COMPONENT_TYPES.MEASURES.value,
+        label: COMPONENT_TYPES.MEASURES.label,
+        acronym: COMPONENT_TYPES.MEASURES.acronym,
+        position: 4,
+    },
+    {
+        type: COMPONENT_TYPES.SUPPORT.value,
+        label: COMPONENT_TYPES.SUPPORT.label,
+        acronym: COMPONENT_TYPES.SUPPORT.acronym,
+        position: 5,
+    },
+];
+const componentPosition = new Map(componentDefinitions.map((component) => [component.type, component.position]));
+function elementPositionInSchema(type) {
+    for (const [component, elements] of Object.entries(SKHEMA_MAPPING.elementFlow)) {
+        const index = elements.findIndex((element) => element.value === type);
+        if (index === -1)
+            continue;
+        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.",
+    ], {
+        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.",
+            },
+        },
+    }),
+    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.",
+            },
+        },
+    }),
+    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"],
+        methodSlots: impactSlots,
+        rules: {
+            minimumRequiredSlots: 2,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: guidingPolicySlots,
+        allowedEntityTypes: [
+            "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.",
+            },
+        },
+    }),
+    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.",
+            },
+        },
+    }),
+    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"],
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: constraintSlots,
+        allowedEntityTypes: [
+            "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.",
+            },
+        },
+    }),
+    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"],
+        methodSlots: solutionSlots,
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: assumptionHypothesisSlots,
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: experimentSlots,
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: actionSlots,
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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."], {
+        methodSlots: investmentSlots,
+        rules: {
+            minimumRequiredSlots: 2,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: estimateSlots,
+        rules: {
+            minimumRequiredSlots: 2,
+            diagnostics: {
+                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%.",
+    ], {
+        methodSlots: baselineSlots,
+        rules: {
+            minimumRequiredSlots: 2,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: outcomeSlots,
+        rules: {
+            minimumRequiredSlots: 2,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: performanceVariableSlots,
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: capabilitySlots,
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: systemSlots,
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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.",
+    ], {
+        methodSlots: principleSlots,
+        rules: {
+            minimumRequiredSlots: 1,
+            diagnostics: {
+                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",
+        requiredForCompleteness: true,
+        diagnostics: {
+            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",
+        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."),
+];
+//# sourceMappingURL=definitions.js.map