@skhema/method 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-export * from "./types.js";
-export * from "./definitions.js";
-export * from "./registry.js";
-export * from "./validate.js";
-export * from "./domain/index.js";
-//# sourceMappingURL=index.d.ts.map
+export * from './definitions.js';
+export * from './registry.js';
+export * from './types.js';
+export * from './validate.js';
+export * from './vocabulary/index.js';

package/dist/index.js

@@ -1,6 +1,5 @@
-export * from "./types.js";
-export * from "./definitions.js";
-export * from "./registry.js";
-export * from "./validate.js";
-export * from "./domain/index.js";
-//# sourceMappingURL=index.js.map
+export * from './definitions.js';
+export * from './registry.js';
+export * from './types.js';
+export * from './validate.js';
+export * from './vocabulary/index.js';

package/dist/registry.d.ts

@@ -1,4 +1,5 @@
-import type { ComponentType, ElementDefinition, ElementType } from "./types.js";
+import type { ElementDefinition } from './types.js';
+import type { ComponentValue, ElementValue } from './vocabulary/index.js';
 export declare function listComponents(): ({
     readonly type: "diagnosis";
     readonly label: "Diagnosis";
@@ -27,24 +28,23 @@ export declare function listComponents(): ({
 })[];
 export declare function listElements(): ElementDefinition[];
 export declare function listElementRelationships(): import("./types.js").ElementRelationshipDefinition[];
-export declare function getElementDefinition(elementType: ElementType | string): ElementDefinition | null;
-export declare function isCanonicalElementType(elementType: ElementType | string): boolean;
-export declare function listElementsForComponent(component: ComponentType): ElementDefinition[];
-export declare function getRequiredMethodSlots(elementType: ElementType | string): import("./types.js").MethodSlotDefinition[];
-export declare function getOptionalMethodSlots(elementType: ElementType | string): import("./types.js").MethodSlotDefinition[];
-export declare function getMethodSlotDefinition(elementType: ElementType | string, slotId: string): import("./types.js").MethodSlotDefinition | null;
-export declare function getElementRequiredSlotIds(elementType: ElementType | string): string[];
-export declare function getElementOptionalSlotIds(elementType: ElementType | string): string[];
-export declare function getElementSubstitutableSlotIds(elementType: ElementType | string): string[];
-export declare function getElementDiagnostics(elementType: ElementType | string): (import("./types.js").MethodDiagnosticMessages & {
+export declare function getElementDefinition(elementType: ElementValue | string): ElementDefinition | null;
+export declare function isCanonicalElementType(elementType: ElementValue | string): boolean;
+export declare function listElementsForComponent(component: ComponentValue): ElementDefinition[];
+export declare function getRequiredMethodSlots(elementType: ElementValue | string): import("./types.js").MethodSlotDefinition[];
+export declare function getOptionalMethodSlots(elementType: ElementValue | string): import("./types.js").MethodSlotDefinition[];
+export declare function getMethodSlotDefinition(elementType: ElementValue | string, slotId: string): import("./types.js").MethodSlotDefinition | null;
+export declare function getElementRequiredSlotIds(elementType: ElementValue | string): string[];
+export declare function getElementOptionalSlotIds(elementType: ElementValue | string): string[];
+export declare function getElementSubstitutableSlotIds(elementType: ElementValue | string): string[];
+export declare function getElementDiagnostics(elementType: ElementValue | string): (import("./types.js").MethodDiagnosticMessages & {
     wrongMood?: string;
     insufficient?: string;
 }) | null;
-export declare function getValidRelationshipsForElement(elementType: ElementType | string): import("./types.js").ElementRelationshipDefinition[];
-export declare function getOutgoingRelationshipsForElement(elementType: ElementType | string): import("./types.js").ElementRelationshipDefinition[];
-export declare function getIncomingRelationshipsForElement(elementType: ElementType | string): import("./types.js").ElementRelationshipDefinition[];
-export declare function getUpstreamElementTypes(elementType: ElementType | string): ("key_challenge" | "supporting_fact" | "impact" | "guiding_policy" | "competitor_move" | "scope" | "constraint" | "solution" | "assumption_hypothesis" | "experiment" | "action" | "investment" | "estimate" | "baseline" | "outcome" | "performance_variable" | "capability" | "system" | "principle")[];
-export declare function getDownstreamElementTypes(elementType: ElementType | string): ("key_challenge" | "supporting_fact" | "impact" | "guiding_policy" | "competitor_move" | "scope" | "constraint" | "solution" | "assumption_hypothesis" | "experiment" | "action" | "investment" | "estimate" | "baseline" | "outcome" | "performance_variable" | "capability" | "system" | "principle")[];
-export declare function getRelationshipDefinition(source: ElementType | string, target: ElementType | string, type?: string): import("./types.js").ElementRelationshipDefinition | null;
-export declare function getCompletenessRelationships(elementType: ElementType | string): import("./types.js").ElementRelationshipDefinition[];
-//# sourceMappingURL=registry.d.ts.map
+export declare function getValidRelationshipsForElement(elementType: ElementValue | string): import("./types.js").ElementRelationshipDefinition[];
+export declare function getOutgoingRelationshipsForElement(elementType: ElementValue | string): import("./types.js").ElementRelationshipDefinition[];
+export declare function getIncomingRelationshipsForElement(elementType: ElementValue | string): import("./types.js").ElementRelationshipDefinition[];
+export declare function getUpstreamElementTypes(elementType: ElementValue | string): ("key_challenge" | "supporting_fact" | "impact" | "guiding_policy" | "competitor_move" | "scope" | "constraint" | "solution" | "assumption_hypothesis" | "experiment" | "action" | "investment" | "estimate" | "baseline" | "outcome" | "performance_variable" | "capability" | "system" | "principle")[];
+export declare function getDownstreamElementTypes(elementType: ElementValue | string): ("key_challenge" | "supporting_fact" | "impact" | "guiding_policy" | "competitor_move" | "scope" | "constraint" | "solution" | "assumption_hypothesis" | "experiment" | "action" | "investment" | "estimate" | "baseline" | "outcome" | "performance_variable" | "capability" | "system" | "principle")[];
+export declare function getRelationshipDefinition(source: ElementValue | string, target: ElementValue | string, type?: string): import("./types.js").ElementRelationshipDefinition | null;
+export declare function getCompletenessRelationships(elementType: ElementValue | string): import("./types.js").ElementRelationshipDefinition[];

package/dist/registry.js

@@ -1,4 +1,4 @@
-import { componentDefinitions, elementDefinitions, elementRelationshipDefinitions, } from "./definitions.js";
+import { componentDefinitions, elementDefinitions, elementRelationshipDefinitions, } from './definitions.js';
 const elementsByType = new Map();
 const canonicalElementTypes = new Set();
 for (const definition of elementDefinitions) {
@@ -27,13 +27,13 @@ export function listElementsForComponent(component) {
     return elementDefinitions.filter((definition) => definition.component === component);
 }
 export function getRequiredMethodSlots(elementType) {
-    return getElementDefinition(elementType)?.methodSlots.filter((slot) => slot.required) ?? [];
+    return (getElementDefinition(elementType)?.methodSlots.filter((slot) => slot.required) ?? []);
 }
 export function getOptionalMethodSlots(elementType) {
-    return getElementDefinition(elementType)?.methodSlots.filter((slot) => !slot.required) ?? [];
+    return (getElementDefinition(elementType)?.methodSlots.filter((slot) => !slot.required) ?? []);
 }
 export function getMethodSlotDefinition(elementType, slotId) {
-    return getElementDefinition(elementType)?.methodSlots.find((slot) => slot.id === slotId) ?? null;
+    return (getElementDefinition(elementType)?.methodSlots.find((slot) => slot.id === slotId) ?? null);
 }
 export function getElementRequiredSlotIds(elementType) {
     return getRequiredMethodSlots(elementType).map((slot) => slot.id);
@@ -42,9 +42,9 @@ export function getElementOptionalSlotIds(elementType) {
     return getOptionalMethodSlots(elementType).map((slot) => slot.id);
 }
 export function getElementSubstitutableSlotIds(elementType) {
-    return getElementDefinition(elementType)?.methodSlots
-        .filter((slot) => slot.substitutable)
-        .map((slot) => slot.id) ?? [];
+    return (getElementDefinition(elementType)
+        ?.methodSlots.filter((slot) => slot.substitutable)
+        .map((slot) => slot.id) ?? []);
 }
 export function getElementDiagnostics(elementType) {
     return getElementDefinition(elementType)?.rules.diagnostics ?? null;
@@ -53,7 +53,8 @@ export function getValidRelationshipsForElement(elementType) {
     const definition = getElementDefinition(elementType);
     if (!definition)
         return [];
-    return elementRelationshipDefinitions.filter((relationship) => relationship.source === definition.type || relationship.target === definition.type);
+    return elementRelationshipDefinitions.filter((relationship) => relationship.source === definition.type ||
+        relationship.target === definition.type);
 }
 export function getOutgoingRelationshipsForElement(elementType) {
     const definition = getElementDefinition(elementType);
@@ -78,15 +79,15 @@ export function getRelationshipDefinition(source, target, type) {
     const targetDefinition = getElementDefinition(target);
     if (!sourceDefinition || !targetDefinition)
         return null;
-    return elementRelationshipDefinitions.find((relationship) => relationship.source === sourceDefinition.type &&
+    return (elementRelationshipDefinitions.find((relationship) => relationship.source === sourceDefinition.type &&
         relationship.target === targetDefinition.type &&
-        (!type || relationship.type === type)) ?? null;
+        (!type || relationship.type === type)) ?? null);
 }
 export function getCompletenessRelationships(elementType) {
     const definition = getElementDefinition(elementType);
     if (!definition)
         return [];
     return elementRelationshipDefinitions.filter((relationship) => relationship.requiredForCompleteness &&
-        (relationship.source === definition.type || relationship.target === definition.type));
+        (relationship.source === definition.type ||
+            relationship.target === definition.type));
 }
-//# sourceMappingURL=registry.js.map

package/dist/types.d.ts

@@ -1,13 +1,11 @@
-import type { ComponentValue as SkhemaComponentValue, ElementValue as SkhemaElementValue } from "@skhema/types/schema";
-export type ComponentType = SkhemaComponentValue;
-export type ElementType = SkhemaElementValue;
-export type ExpectedMood = "indicative" | "imperative" | "noun_phrase";
-export type SlotCardinality = "zero_or_one" | "exactly_one" | "zero_or_more" | "one_or_more";
-export type SlotEvidenceRequirement = "explicit_span_required" | "explicit_or_inferred" | "not_required";
-export type SlotInferencePolicy = "not_allowed" | "allowed" | "required_when_missing";
-export type RelationshipCardinality = "zero_or_one" | "one_or_one" | "zero_or_more" | "one_or_more";
-export type RelationshipEvidenceRequirement = "explicit_link" | "semantic_alignment" | "entity_overlap" | "not_required";
-export type RelationshipScope = "same_element" | "same_component" | "same_strategy" | "same_workspace";
+import type { ComponentValue, ElementValue } from './vocabulary/index.js';
+export type ExpectedMood = 'indicative' | 'imperative' | 'noun_phrase';
+export type SlotCardinality = 'zero_or_one' | 'exactly_one' | 'zero_or_more' | 'one_or_more';
+export type SlotEvidenceRequirement = 'explicit_span_required' | 'explicit_or_inferred' | 'not_required';
+export type SlotInferencePolicy = 'not_allowed' | 'allowed' | 'required_when_missing';
+export type RelationshipCardinality = 'zero_or_one' | 'one_or_one' | 'zero_or_more' | 'one_or_more';
+export type RelationshipEvidenceRequirement = 'explicit_link' | 'semantic_alignment' | 'entity_overlap' | 'not_required';
+export type RelationshipScope = 'same_element' | 'same_component' | 'same_strategy' | 'same_workspace';
 export interface MethodDiagnosticMessages {
     missing?: string;
     weak?: string;
@@ -23,7 +21,7 @@ export interface ElementMethodRules {
     };
 }
 export interface ComponentDefinition {
-    type: ComponentType;
+    type: ComponentValue;
     label: string;
     acronym: string;
     position: number;
@@ -48,10 +46,10 @@ export interface SyntacticSlotDefinition {
     required: boolean;
 }
 export interface ElementDefinition {
-    type: ElementType;
+    type: ElementValue;
     label: string;
     acronym: string;
-    component: ComponentType;
+    component: ComponentValue;
     position: number;
     expectedMood: ExpectedMood;
     aliases?: string[];
@@ -62,8 +60,8 @@ export interface ElementDefinition {
     rules: ElementMethodRules;
 }
 export interface ElementRelationshipDefinition {
-    source: ElementType;
-    target: ElementType;
+    source: ElementValue;
+    target: ElementValue;
     type: string;
     label: string;
     description: string;
@@ -73,11 +71,10 @@ export interface ElementRelationshipDefinition {
     scope: RelationshipScope[];
     diagnostics: MethodDiagnosticMessages;
 }
-export type MethodSpecIssueSeverity = "error" | "warning";
+export type MethodSpecIssueSeverity = 'error' | 'warning';
 export interface MethodSpecIssue {
     severity: MethodSpecIssueSeverity;
     code: string;
     message: string;
     path: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/validate.d.ts

@@ -1,4 +1,3 @@
-import type { MethodSpecIssue } from "./types.js";
+import type { MethodSpecIssue } from './types.js';
 export declare function validateMethodSpec(): MethodSpecIssue[];
 export declare function assertValidMethodSpec(): void;
-//# sourceMappingURL=validate.d.ts.map

package/dist/validate.js

@@ -1,6 +1,5 @@
-import { COMPONENT_TYPES, ELEMENT_TYPES, SKHEMA_MAPPING } from "@skhema/types/schema";
-import { elementDefinitions, elementRelationshipDefinitions, } from "./definitions.js";
-import { isKnownEntityType } from "./domain/entity-types.js";
+import { elementDefinitions, elementRelationshipDefinitions, } from './definitions.js';
+import { COMPONENT_TYPES, ELEMENT_TYPES, SKHEMA_MAPPING, } from './vocabulary/index.js';
 const canonicalElementTypes = new Set(Object.values(ELEMENT_TYPES).map((element) => element.value));
 const canonicalComponentTypes = new Set(Object.values(COMPONENT_TYPES).map((component) => component.value));
 function issue(severity, code, path, message) {
@@ -10,38 +9,31 @@ function validateSlot(element, slot, index) {
     const path = `elements.${element.type}.methodSlots.${index}`;
     const issues = [];
     if (!slot.id) {
-        issues.push(issue("error", "slot_id_missing", path, "Method slot id is required."));
+        issues.push(issue('error', 'slot_id_missing', path, 'Method slot id is required.'));
     }
     if (!slot.label) {
-        issues.push(issue("error", "slot_label_missing", path, "Method slot label is required."));
+        issues.push(issue('error', 'slot_label_missing', path, 'Method slot label is required.'));
     }
     if (!slot.description) {
-        issues.push(issue("error", "slot_description_missing", path, "Method slot description is required."));
+        issues.push(issue('error', 'slot_description_missing', path, 'Method slot description is required.'));
     }
     if (!slot.cardinality) {
-        issues.push(issue("error", "slot_cardinality_missing", path, "Method slot cardinality is required."));
+        issues.push(issue('error', 'slot_cardinality_missing', path, 'Method slot cardinality is required.'));
     }
     if (!slot.evidence) {
-        issues.push(issue("error", "slot_evidence_missing", path, "Method slot evidence requirement is required."));
+        issues.push(issue('error', 'slot_evidence_missing', path, 'Method slot evidence requirement is required.'));
     }
     if (!slot.inference) {
-        issues.push(issue("error", "slot_inference_missing", path, "Method slot inference policy is required."));
+        issues.push(issue('error', 'slot_inference_missing', path, 'Method slot inference policy is required.'));
     }
     if (!Array.isArray(slot.acceptedEntityTypes)) {
-        issues.push(issue("error", "slot_entity_types_invalid", path, "Method slot acceptedEntityTypes must be an array."));
+        issues.push(issue('error', 'slot_entity_types_invalid', path, 'Method slot acceptedEntityTypes must be an array.'));
     }
-    else {
-        for (const entityType of slot.acceptedEntityTypes) {
-            if (!isKnownEntityType(entityType)) {
-                issues.push(issue("error", "slot_entity_type_unknown", path, `acceptedEntityTypes references "${entityType}", which is not a canonical entity type. Add it to entity-type-definitions.ts.`));
-            }
-        }
-    }
-    if (!slot.diagnostics || typeof slot.diagnostics !== "object") {
-        issues.push(issue("error", "slot_diagnostics_missing", path, "Method slot diagnostics are required."));
+    if (!slot.diagnostics || typeof slot.diagnostics !== 'object') {
+        issues.push(issue('error', 'slot_diagnostics_missing', path, 'Method slot diagnostics are required.'));
     }
     if (slot.required && !slot.diagnostics?.missing) {
-        issues.push(issue("warning", "slot_missing_diagnostic_absent", path, "Required method slots should provide a missing diagnostic."));
+        issues.push(issue('warning', 'slot_missing_diagnostic_absent', path, 'Required method slots should provide a missing diagnostic.'));
     }
     return issues;
 }
@@ -49,41 +41,41 @@ function validateElementDefinition(element) {
     const path = `elements.${element.type}`;
     const issues = [];
     if (!canonicalElementTypes.has(element.type)) {
-        issues.push(issue("error", "element_not_canonical", path, `${element.type} is not in @skhema/types/schema.`));
+        issues.push(issue('error', 'element_not_canonical', path, `${element.type} is not in the Skhema method vocabulary.`));
     }
     if (!canonicalComponentTypes.has(element.component)) {
-        issues.push(issue("error", "component_not_canonical", path, `${element.component} is not in @skhema/types/schema.`));
+        issues.push(issue('error', 'component_not_canonical', path, `${element.component} is not in the Skhema method vocabulary.`));
     }
     if (!element.expectedMood) {
-        issues.push(issue("error", "expected_mood_missing", path, "Expected mood is required."));
+        issues.push(issue('error', 'expected_mood_missing', path, 'Expected mood is required.'));
     }
     if (element.syntacticSlots.length === 0) {
-        issues.push(issue("error", "syntactic_slots_missing", path, "At least one syntactic slot is required."));
+        issues.push(issue('error', 'syntactic_slots_missing', path, 'At least one syntactic slot is required.'));
     }
     if (element.methodSlots.length === 0) {
-        issues.push(issue("error", "method_slots_missing", path, "At least one method slot is required."));
+        issues.push(issue('error', 'method_slots_missing', path, 'At least one method slot is required.'));
     }
     if (element.rules.examplesRequired && element.examples.length === 0) {
-        issues.push(issue("warning", "examples_missing", path, "Element definitions should include examples."));
+        issues.push(issue('warning', 'examples_missing', path, 'Element definitions should include examples.'));
     }
     if (!element.rules) {
-        issues.push(issue("error", "element_rules_missing", path, "Element method rules are required."));
+        issues.push(issue('error', 'element_rules_missing', path, 'Element method rules are required.'));
     }
     else {
-        if (typeof element.rules.examplesRequired !== "boolean") {
-            issues.push(issue("error", "element_examples_rule_missing", path, "examplesRequired rule is required."));
+        if (typeof element.rules.examplesRequired !== 'boolean') {
+            issues.push(issue('error', 'element_examples_rule_missing', path, 'examplesRequired rule is required.'));
         }
-        if (typeof element.rules.minimumRequiredSlots !== "number") {
-            issues.push(issue("error", "element_minimum_required_slots_missing", path, "minimumRequiredSlots rule is required."));
+        if (typeof element.rules.minimumRequiredSlots !== 'number') {
+            issues.push(issue('error', 'element_minimum_required_slots_missing', path, 'minimumRequiredSlots rule is required.'));
         }
-        if (typeof element.rules.allowInference !== "boolean") {
-            issues.push(issue("error", "element_inference_rule_missing", path, "allowInference rule is required."));
+        if (typeof element.rules.allowInference !== 'boolean') {
+            issues.push(issue('error', 'element_inference_rule_missing', path, 'allowInference rule is required.'));
         }
         if (!element.rules.diagnostics?.wrongMood) {
-            issues.push(issue("error", "element_wrong_mood_diagnostic_missing", path, "wrongMood diagnostic is required."));
+            issues.push(issue('error', 'element_wrong_mood_diagnostic_missing', path, 'wrongMood diagnostic is required.'));
         }
         if (!element.rules.diagnostics?.insufficient) {
-            issues.push(issue("error", "element_insufficient_diagnostic_missing", path, "insufficient diagnostic is required."));
+            issues.push(issue('error', 'element_insufficient_diagnostic_missing', path, 'insufficient diagnostic is required.'));
         }
     }
     for (const [index, slot] of element.methodSlots.entries()) {
@@ -95,28 +87,30 @@ function validateRelationship(relationship, index) {
     const path = `relationships.${index}`;
     const issues = [];
     if (!canonicalElementTypes.has(relationship.source)) {
-        issues.push(issue("error", "relationship_source_not_canonical", path, `${relationship.source} is not in @skhema/types/schema.`));
+        issues.push(issue('error', 'relationship_source_not_canonical', path, `${relationship.source} is not in the Skhema method vocabulary.`));
     }
     if (!canonicalElementTypes.has(relationship.target)) {
-        issues.push(issue("error", "relationship_target_not_canonical", path, `${relationship.target} is not in @skhema/types/schema.`));
+        issues.push(issue('error', 'relationship_target_not_canonical', path, `${relationship.target} is not in the Skhema method vocabulary.`));
     }
     if (!relationship.type) {
-        issues.push(issue("error", "relationship_type_missing", path, "Relationship type is required."));
+        issues.push(issue('error', 'relationship_type_missing', path, 'Relationship type is required.'));
     }
     if (!relationship.cardinality) {
-        issues.push(issue("error", "relationship_cardinality_missing", path, "Relationship cardinality is required."));
+        issues.push(issue('error', 'relationship_cardinality_missing', path, 'Relationship cardinality is required.'));
     }
     if (!relationship.evidence) {
-        issues.push(issue("error", "relationship_evidence_missing", path, "Relationship evidence is required."));
+        issues.push(issue('error', 'relationship_evidence_missing', path, 'Relationship evidence is required.'));
     }
     if (!Array.isArray(relationship.scope) || relationship.scope.length === 0) {
-        issues.push(issue("error", "relationship_scope_missing", path, "Relationship scope is required."));
+        issues.push(issue('error', 'relationship_scope_missing', path, 'Relationship scope is required.'));
     }
-    if (!relationship.diagnostics || typeof relationship.diagnostics !== "object") {
-        issues.push(issue("error", "relationship_diagnostics_missing", path, "Relationship diagnostics are required."));
+    if (!relationship.diagnostics ||
+        typeof relationship.diagnostics !== 'object') {
+        issues.push(issue('error', 'relationship_diagnostics_missing', path, 'Relationship diagnostics are required.'));
     }
-    if (relationship.requiredForCompleteness && !relationship.diagnostics.missing) {
-        issues.push(issue("warning", "relationship_missing_diagnostic_absent", path, "Completeness relationships should provide a missing diagnostic."));
+    if (relationship.requiredForCompleteness &&
+        !relationship.diagnostics.missing) {
+        issues.push(issue('warning', 'relationship_missing_diagnostic_absent', path, 'Completeness relationships should provide a missing diagnostic.'));
     }
     return issues;
 }
@@ -125,32 +119,31 @@ export function validateMethodSpec() {
     const definedElementTypes = new Set(elementDefinitions.map((element) => element.type));
     for (const element of Object.values(ELEMENT_TYPES)) {
         if (!definedElementTypes.has(element.value)) {
-            issues.push(issue("error", "canonical_element_missing", `elements.${element.value}`, `${element.value} is missing from @skhema/method.`));
+            issues.push(issue('error', 'canonical_element_missing', `elements.${element.value}`, `${element.value} is missing an element definition in @skhema/method.`));
         }
     }
     for (const [component, schemaElements] of Object.entries(SKHEMA_MAPPING.elementFlow)) {
         for (const schemaElement of schemaElements) {
             const definition = elementDefinitions.find((element) => element.type === schemaElement.value);
             if (definition && definition.component !== component) {
-                issues.push(issue("error", "component_assignment_mismatch", `elements.${definition.type}.component`, `${definition.type} should be assigned to ${component}.`));
+                issues.push(issue('error', 'component_assignment_mismatch', `elements.${definition.type}.component`, `${definition.type} should be assigned to ${component}.`));
             }
         }
     }
     for (const element of elementDefinitions) {
         issues.push(...validateElementDefinition(element));
     }
-    for (const [index, relationship] of elementRelationshipDefinitions.entries()) {
+    for (const [index, relationship,] of elementRelationshipDefinitions.entries()) {
         issues.push(...validateRelationship(relationship, index));
     }
     return issues;
 }
 export function assertValidMethodSpec() {
-    const errors = validateMethodSpec().filter((candidate) => candidate.severity === "error");
+    const errors = validateMethodSpec().filter((candidate) => candidate.severity === 'error');
     if (errors.length === 0)
         return;
     const summary = errors
         .map((candidate) => `${candidate.code} at ${candidate.path}: ${candidate.message}`)
-        .join("\n");
+        .join('\n');
     throw new Error(`Invalid @skhema/method specification:\n${summary}`);
 }
-//# sourceMappingURL=validate.js.map

package/dist/vocabulary/components.d.ts

@@ -0,0 +1,32 @@
+export declare const COMPONENT_TYPES: {
+    readonly DIAGNOSIS: {
+        readonly value: "diagnosis";
+        readonly label: "Diagnosis";
+        readonly acronym: "BD";
+    };
+    readonly METHOD: {
+        readonly value: "method";
+        readonly label: "Method & Positioning";
+        readonly acronym: "MP";
+    };
+    readonly INITIATIVES: {
+        readonly value: "initiatives";
+        readonly label: "Portfolio of Initiatives";
+        readonly acronym: "PI";
+    };
+    readonly MEASURES: {
+        readonly value: "measures";
+        readonly label: "Measures";
+        readonly acronym: "M";
+    };
+    readonly SUPPORT: {
+        readonly value: "support";
+        readonly label: "Support Structures";
+        readonly acronym: "SS";
+    };
+};
+export type ComponentType = (typeof COMPONENT_TYPES)[keyof typeof COMPONENT_TYPES];
+export type ComponentTypeKey = keyof typeof COMPONENT_TYPES;
+export type ComponentValue = ComponentType['value'];
+export type ComponentLabel = ComponentType['label'];
+export type ComponentAcronym = ComponentType['acronym'];

package/dist/vocabulary/components.js

@@ -0,0 +1,27 @@
+export const COMPONENT_TYPES = {
+    DIAGNOSIS: {
+        value: 'diagnosis',
+        label: 'Diagnosis',
+        acronym: 'BD',
+    },
+    METHOD: {
+        value: 'method',
+        label: 'Method & Positioning',
+        acronym: 'MP',
+    },
+    INITIATIVES: {
+        value: 'initiatives',
+        label: 'Portfolio of Initiatives',
+        acronym: 'PI',
+    },
+    MEASURES: {
+        value: 'measures',
+        label: 'Measures',
+        acronym: 'M',
+    },
+    SUPPORT: {
+        value: 'support',
+        label: 'Support Structures',
+        acronym: 'SS',
+    },
+};

package/dist/vocabulary/elements.d.ts

@@ -0,0 +1,102 @@
+export declare const ELEMENT_TYPES: {
+    readonly KEY_CHALLENGE: {
+        readonly value: "key_challenge";
+        readonly label: "Key Challenge";
+        readonly acronym: "CHL";
+    };
+    readonly SUPPORTING_FACT: {
+        readonly value: "supporting_fact";
+        readonly label: "Supporting Fact";
+        readonly acronym: "FCT";
+    };
+    readonly IMPACT: {
+        readonly value: "impact";
+        readonly label: "Impact";
+        readonly acronym: "IMP";
+    };
+    readonly GUIDING_POLICY: {
+        readonly value: "guiding_policy";
+        readonly label: "Guiding Policy";
+        readonly acronym: "POL";
+    };
+    readonly COMPETITOR_MOVE: {
+        readonly value: "competitor_move";
+        readonly label: "Competitor Move";
+        readonly acronym: "CMV";
+    };
+    readonly SCOPE: {
+        readonly value: "scope";
+        readonly label: "Scope";
+        readonly acronym: "SCP";
+    };
+    readonly CONSTRAINT: {
+        readonly value: "constraint";
+        readonly label: "Constraint";
+        readonly acronym: "CST";
+    };
+    readonly SOLUTION: {
+        readonly value: "solution";
+        readonly label: "Solution";
+        readonly acronym: "SOL";
+    };
+    readonly ASSUMPTION_HYPOTHESIS: {
+        readonly value: "assumption_hypothesis";
+        readonly label: "Assumption Hypothesis";
+        readonly acronym: "HYP";
+    };
+    readonly EXPERIMENT: {
+        readonly value: "experiment";
+        readonly label: "Experiment";
+        readonly acronym: "EXP";
+    };
+    readonly ACTION: {
+        readonly value: "action";
+        readonly label: "Action";
+        readonly acronym: "ACT";
+    };
+    readonly INVESTMENT: {
+        readonly value: "investment";
+        readonly label: "Investment";
+        readonly acronym: "INV";
+    };
+    readonly ESTIMATE: {
+        readonly value: "estimate";
+        readonly label: "Estimate";
+        readonly acronym: "EST";
+    };
+    readonly BASELINE: {
+        readonly value: "baseline";
+        readonly label: "Baseline";
+        readonly acronym: "BSL";
+    };
+    readonly OUTCOME: {
+        readonly value: "outcome";
+        readonly label: "Outcome";
+        readonly acronym: "OCM";
+    };
+    readonly PERFORMANCE_VARIABLE: {
+        readonly value: "performance_variable";
+        readonly label: "Performance Variable";
+        readonly acronym: "VAR";
+    };
+    readonly CAPABILITY: {
+        readonly value: "capability";
+        readonly label: "Capability";
+        readonly acronym: "CAP";
+    };
+    readonly SYSTEM: {
+        readonly value: "system";
+        readonly label: "System";
+        readonly acronym: "SYS";
+    };
+    readonly PRINCIPLE: {
+        readonly value: "principle";
+        readonly label: "Principle";
+        readonly acronym: "PRN";
+    };
+};
+export type ElementType = (typeof ELEMENT_TYPES)[keyof typeof ELEMENT_TYPES];
+export type ElementTypeKey = keyof typeof ELEMENT_TYPES;
+export type ElementValue = ElementType['value'];
+export type ElementLabel = ElementType['label'];
+export type ElementAcronym = ElementType['acronym'];