ipa-core 1.2.1 → 1.3.1

package/core.js

@@ -95,7 +95,7 @@ const core = {
     'ʢ': { type: "consonant", features: { manner: "fricative/approximant", place: "epiglottal", voicing: "voiced" }, airstream: "pulmonic" },
     'ʡ': { type: "consonant", features: { manner: "plosive", place: "epiglottal", voicing: "voiceless" }, airstream: "pulmonic" },
     //coarticulated
-    'ɧ': { type: "consonant", coarticulated: true, components: ["ʃ", "x"] },
+    // 'ɧ': { type: "consonant", coarticulated: true, components: ["ʃ", "x"] },
     //vowels
     //front
     'i': { type: "vowel", features: { height: "close", backness: "front", rounding: "unrounded" }, airstream: "pulmonic" },

package/dictionary.js

@@ -0,0 +1,105 @@
+const dictionary = {
+  // AIRSTREAM
+  pulmonic: "Use airflow from the lungs to produce the sound",
+  "glottalic ingressive": "Draw air inward using the glottis mechanism",
+  "lingual ingressive": "Draw air inward using the tongue (click mechanism)",
+  ejective: "Release a burst of air using a glottalic upward push",
+
+  // MANNER
+  plosive: "Completely block airflow, build pressure, then release it in a burst",
+  nasal: "Lower the velum so air flows through the nose",
+  trill: "Allow an articulator to vibrate rapidly in the airstream",
+  "tap/flap": "Make a single quick strike of an articulator against its contact point",
+  fricative: "Narrow the airflow channel to create friction noise",
+  approximant: "Shape the mouth for sound without creating turbulent airflow",
+  "lateral fricative": "Direct airflow along the sides of the tongue while creating friction",
+  "lateral approximant": "Allow air to flow smoothly along the sides of the tongue",
+  click: "Create a suction pocket in the mouth and release it sharply",
+
+  // PLACE
+  bilabial: "Bring both lips together",
+  labiodental: "Place lower lip against upper teeth",
+  dental: "Place the tongue against the teeth",
+  alveolar: "Place the tongue at the alveolar ridge just behind the teeth",
+  postalveolar: "Place the tongue just behind the alveolar ridge",
+  retroflex: "Curl the tongue tip backward toward the palate",
+  palatal: "Raise the middle of the tongue to the hard palate",
+  velar: "Raise the back of the tongue to the soft palate",
+  uvular: "Raise the back of the tongue toward the uvula",
+  pharyngeal: "Constrict the throat in the pharynx area",
+  glottal: "Use the vocal folds as the place of articulation",
+  epiglottal: "Use the epiglottis to constrict airflow",
+
+  // COMPLEX PLACE TYPES
+  "alveolo-palatal": "Position the tongue between the alveolar ridge and hard palate",
+  "labial-velar": "Simultaneously use the lips and the soft palate",
+
+  // VOICING
+  voiceless: "Do not vibrate the vocal cords",
+  voiced: "Vibrate the vocal cords",
+
+  // VOWEL HEIGHT
+  close: "Raise the tongue high in the mouth",
+  "near-close": "Raise the tongue slightly lower than close vowels",
+  "close-mid": "Position the tongue between close and mid height",
+  mid: "Keep the tongue in a neutral height position",
+  "open-mid": "Lower the tongue between mid and open",
+  "near-open": "Lower the tongue slightly above fully open",
+  open: "Lower the tongue as far as possible",
+
+  // VOWEL BACKNESS
+  front: "Position the tongue toward the front of the mouth",
+  central: "Position the tongue in the center of the mouth",
+  back: "Position the tongue toward the back of the mouth",
+
+  // ROUNDING
+  rounded: "Round the lips",
+  unrounded: "Keep the lips relaxed and unrounded",
+
+  // LENGTH
+  "extra-short": "Produce the sound with very short duration",
+  "half-long": "Hold the sound slightly longer than normal",
+  long: "Hold the sound for an extended duration",
+
+  // TONE
+  high: "Produce the sound with a high pitch",
+  low: "Produce the sound with a low pitch",
+  rising: "Start low and move to a higher pitch",
+  falling: "Start high and move to a lower pitch",
+  "extra-high": "Produce the sound with a very high pitch",
+  "extra-low": "Produce the sound with a very low pitch",
+
+  // TONE MODIFIERS
+  downstep: "Lower pitch relative to the previous tone",
+  upstep: "Raise pitch relative to the previous tone",
+
+  // RELEASE
+  none: "Do not release the closure audibly",
+
+  // SECONDARY ARTICULATION
+  aspirated: "Release the sound with a strong burst of air",
+  palatalized: "Raise the tongue toward the hard palate during articulation",
+  velarized: "Raise the back of the tongue toward the soft palate",
+  labialized: "Round the lips during articulation",
+  pharyngealized: "Constrict the pharynx during articulation",
+
+  // PHONATION
+  creaky_voice: "Use irregular vocal fold vibration",
+  breathy_voice: "Allow extra airflow through loosely vibrating vocal folds",
+
+  // NASALIZATION / RHOTICITY
+  nasalized: "Lower the velum so air escapes through the nose during articulation",
+  rhoticity: "Add an r-colored quality to the sound",
+
+  // CONSONANT/VOWEL TYPES
+  consonant: "Produce a sound with significant constriction of airflow",
+  vowel: "Produce a sound without significant obstruction of airflow",
+
+  // SEQUENCE TYPES
+  affricate: "Begin with a complete stop, then release into a fricative",
+  diphthong: "Move smoothly from one vowel position to another within a single syllable",
+  syllable: "Produce a single rhythmic unit centered around a vowel",
+  coarticulation: "Overlap articulations between adjacent sounds"
+};
+
+module.exports = dictionary;

package/fill-orthography.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// fill-orthography.js
+// fill-orthography.cjs
 
 const fs = require('fs');
 const path = require('path');
@@ -34,7 +34,7 @@ if (!Array.isArray(alphabet) || alphabet.length === 0) {
 // -----------------------------
 // GENERATE orthography OBJECT STRING
 // -----------------------------
-const orthographyLines = alphabet.map(letter => `  ["${letter}"]: ["", []],`);
+const orthographyLines = alphabet.map(letter => `  // "${letter}": ["", []],`);
 const orthographyString = `const orthography = {\n${orthographyLines.join('\n')}\n};`;
 
 // -----------------------------

package/generate-config.js

@@ -38,9 +38,9 @@ function generateIPASection(core) {
   const grouped = groupByType(core);
   const sections = Object.entries(grouped).map(([type, symbols]) => {
     symbols.sort((a, b) => a.localeCompare(b));
-    return [`// ${type.toUpperCase()}`, wrapSymbols(symbols), ''].join('\n');
+    return [`// ${type.toUpperCase()}`, wrapSymbols(symbols)].join('\n');
   });
-  return ['/**', ' * IPA SYMBOL REFERENCE', ' * Copy/paste symbols as needed', '', ...sections].join('\n');
+  return ['/**', ' * IPA SYMBOL REFERENCE', ' * Copy/paste symbols as needed', ' */', ...sections].join('\n');
 }
 
 // -----------------------------
@@ -73,7 +73,26 @@ function generateModifierSection(modifiers) {
     const appliesTo = Array.isArray(data.appliesTo) ? data.appliesTo.join(', ') : data.appliesTo || '';
     return `${key}(${appliesTo})`;
   });
-  return ['/**', ' * MODIFIER REFERENCE', ' * modifier(appliesTo)', ' */', '', wrapModifiers(formatted), ''].join('\n');
+  return ['/**', ' * MODIFIER REFERENCE', ' * modifier(appliesTo)', ' */', wrapModifiers(formatted)].join('\n');
+}
+
+// -----------------------------
+// SEQUENCE MODIFIER SECTION
+// -----------------------------
+function generateSequenceModifierSection(modifiers) {
+  const sequenceModifiers = Object.entries(modifiers)
+    .filter(([key, data]) => {
+      const appliesTo = data.appliesTo;
+      return Array.isArray(appliesTo) ? appliesTo.includes("sequence") : appliesTo === "sequence";
+    })
+    .map(([key]) => key);
+
+  if (sequenceModifiers.length === 0) {
+    return '';
+  }
+
+  const lines = sequenceModifiers.map(m => `// ${m}`);
+  return ['/**', ' * SEQUENCE MODIFIERS', ' * Add as last element in array', ' */', ...lines].join('\n');
 }
 
 // -----------------------------
@@ -85,7 +104,8 @@ function generateOrthographyExport() {
     '// a: ["ɑ", ["more_rounded"]],',
     '// x̱: [',
     '//   ["k", ["ejective", "aspirated"]],',
-    '//   ["x", []]',
+    '//   ["x", []],',
+    '//   "affricate"',
     '// ],',
     '// l: ["ɬ"]'
   ].join('\n');
@@ -98,14 +118,13 @@ function generateOrthographyExport() {
     ' * Fill in your orthography below; examples are commented out.',
     ' */',
     '',
-    "const { parseConfig } = require('./parser.cjs');",
+    "const { parseConfig } = require('./parser.js');",
     '',
     'const orthography = {',
     commentedOrthography,
     '};',
     '',
-    'module.exports = parseConfig(orthography);',
-    ''
+    'module.exports = parseConfig(orthography);'
   ].join('\n');
 }
 
@@ -113,13 +132,14 @@ function generateOrthographyExport() {
 // MAIN GENERATOR
 // -----------------------------
 function generateConfig() {
-  const content = [
+  const sections = [
     generateIPASection(core),
-    '',
     generateModifierSection(modifiers),
-    '',
+    generateSequenceModifierSection(modifiers),
     generateOrthographyExport()
-  ].join('\n');
+  ].filter(s => s.length > 0);
+
+  const content = sections.join('\n\n');
 
   // Ensure 'ipa' folder exists
   const ipaDir = path.join(process.cwd(), 'ipa');
@@ -133,11 +153,13 @@ function generateConfig() {
 
   console.log('✅ ipa/ipa.config.js generated with parseConfig() export');
 
-  // Write alphabet.js
+  // Write alphabet.js if it doesn't exist
   const alphabetPath = path.join(ipaDir, 'alphabet.js');
-  const alphabetContent = 'const alphabet = [];\nmodule.exports = alphabet;\n';
-  fs.writeFileSync(alphabetPath, alphabetContent, 'utf-8');
-  console.log('✅ ipa/alphabet.js generated with empty alphabet array');
+  if (!fs.existsSync(alphabetPath)) {
+    const alphabetContent = 'const alphabet = [];\nmodule.exports = alphabet;\n';
+    fs.writeFileSync(alphabetPath, alphabetContent, 'utf-8');
+    console.log('✅ ipa/alphabet.js generated with empty alphabet array');
+  }
 }
 
 // RUN

package/generate-conlang.js

@@ -86,11 +86,48 @@ function generateConlang({ alphabet, mod1Chance, mod2Chance, affricateChance })
         orthography[letter] = [
           [ipaKey, modifiersList],
           [fricKey, []],
+          "affricate"
         ];
         return;
       }
     }
 
+    // Diphthong (vowel + vowel sequence)
+    if (baseObj?.type === 'vowel' && Math.random() < 0.3) {
+      const vowels = Object.keys(core).filter(k => core[k].type === 'vowel');
+      const secondVowel = pickRandom(vowels);
+      orthography[letter] = [
+        [ipaKey, modifiersList],
+        [secondVowel, []],
+        "diphthong"
+      ];
+      return;
+    }
+
+    // Syllable (consonant + vowel)
+    if (baseObj?.type === 'consonant' && Math.random() < 0.3) {
+      const vowels = Object.keys(core).filter(k => core[k].type === 'vowel');
+      const vowel = pickRandom(vowels);
+      orthography[letter] = [
+        [ipaKey, modifiersList],
+        [vowel, []],
+        "syllable"
+      ];
+      return;
+    }
+
+    // Coarticulation (consonant + consonant)
+    if (baseObj?.type === 'consonant' && Math.random() < 0.15) {
+      const consonants = Object.keys(core).filter(k => core[k].type === 'consonant');
+      const secondConsonant = pickRandom(consonants);
+      orthography[letter] = [
+        [ipaKey, modifiersList],
+        [secondConsonant, []],
+        "coarticulation"
+      ];
+      return;
+    }
+
     orthography[letter] = [ipaKey, modifiersList];
   });
 

package/get-definitions.js

@@ -0,0 +1,41 @@
+const dictionary = require('./dictionary');
+
+function getDefinitions(phoneme) {
+  const steps = [];
+
+  function collect(p) {
+    if (p.features?.place && dictionary[p.features.place]) {
+      steps.push(dictionary[p.features.place]);
+    }
+
+    if (p.features?.manner && dictionary[p.features.manner]) {
+      steps.push(dictionary[p.features.manner]);
+    }
+
+    if (p.features?.voicing && dictionary[p.features.voicing]) {
+      steps.push(dictionary[p.features.voicing]);
+    }
+
+    if (p.airstream && dictionary[p.airstream]) {
+      steps.push(dictionary[p.airstream]);
+    }
+
+    if (p.modifiersApplied) {
+      for (const mod of p.modifiersApplied) {
+        if (dictionary[mod]) steps.push(dictionary[mod]);
+      }
+    }
+
+    if (p.components) {
+      for (const comp of p.components) {
+        collect(comp); // IMPORTANT: no string recursion
+      }
+    }
+  }
+
+  collect(phoneme);
+
+  return steps.join(". ") + ".";
+}
+
+module.exports = { getDefinitions, dictionary };

package/index.js

@@ -3,6 +3,8 @@ const core = require("./core.js");           // base consonants & vowels
 const modifiers = require("./modifiers.js"); // diacritics, tones, suprasegmentals
 const rules = require("./rules.js");         // modifier compatibility rules
 const parser = require("./parser.js");       // parser (parsePhoneme, parseUnit, parseConfig)
+const dictionary = require("./dictionary.js");      //instructional definitions
+const getDefinitions = require("./get-definitions.js");    //compiles and formats instructions
 
 // Export the layers so users can access them if needed
 const { parsePhoneme, parseUnit, parseConfig } = parser;
@@ -14,5 +16,7 @@ module.exports = {
   parser,
   parsePhoneme,
   parseUnit,
-  parseConfig
+  parseConfig,
+  dictionary,
+  getDefinitions
 };

package/modifiers.js

@@ -20,34 +20,47 @@ const modifiers = {
   more_rounded: {
     symbol: "̹",
     appliesTo: "vowel",
-    effects: { rounding: "more" }
+    effects: { roundingModifier: "more" }
   },
   less_rounded: {
     symbol: "̜",
     appliesTo: "vowel",
-    effects: { rounding: "less" }
+    effects: { roundingModifier: "less" }
   },
 
+  // PLACE: PRIMARY OVERRIDES
+  dental: {
+    symbol: "̪",
+    appliesTo: "consonant",
+    effects: { place: "dental" }
+  },
+  linguolabial: {
+    symbol: "̼",
+    appliesTo: "consonant",
+    effects: { place: "linguolabial" }
+  },
+
+  // PLACE: SHIFTS (DO NOT OVERRIDE)
   advanced: {
     symbol: "̟",
     appliesTo: "consonant",
-    effects: { placeModifier: "advanced" }
+    effects: { placeShift: "advanced" }
   },
   retracted: {
     symbol: "̠",
     appliesTo: "consonant",
-    effects: { placeModifier: "retracted" }
+    effects: { placeShift: "retracted" }
   },
 
   centralized: {
     symbol: "̈",
     appliesTo: "vowel",
-    effects: { backness: "centralized" }
+    effects: { centralization: "centralized" }
   },
   mid_centralized: {
     symbol: "̽",
     appliesTo: "vowel",
-    effects: { backness: "mid-centralized" }
+    effects: { centralization: "mid" }
   },
 
   syllabic: {
@@ -61,29 +74,20 @@ const modifiers = {
     effects: { syllabic: false }
   },
 
-  dental: {
-    symbol: "̪",
-    appliesTo: "consonant",
-    effects: { placeModifier: "dental" }
-  },
   apical: {
     symbol: "̺",
     appliesTo: "consonant",
-    effects: { articulation: "apical" }
+    effects: { tonguePart: "apical" }
   },
   laminal: {
     symbol: "̻",
     appliesTo: "consonant",
-    effects: { articulation: "laminal" }
+    effects: { tonguePart: "laminal" }
   },
 
-  velarized_or_pharyngealized: {
-    symbol: "ˠ",
-    appliesTo: "consonant",
-    effects: { secondaryArticulation: "velarized_or_pharyngealized" }
-  },
+  // SECONDARY ARTICULATION
   velarized: {
-    symbol: "̴",
+    symbol: "ˠ",
     appliesTo: "consonant",
     effects: { secondaryArticulation: "velarized" }
   },
@@ -115,6 +119,7 @@ const modifiers = {
     effects: { rhotic: true }
   },
 
+  // LENGTH
   length_half_long: {
     symbol: "ˑ",
     appliesTo: ["vowel", "consonant"],
@@ -131,15 +136,7 @@ const modifiers = {
     effects: { length: "extra-short" }
   },
 
-  voiceless_flap: {
-    symbol: "̥̆",
-    appliesTo: "consonant",
-    effects: {
-      voicing: "voiceless",
-      mannerModifier: "flap"
-    }
-  },
-
+  // PHONATION
   creaky_voice: {
     symbol: "̰",
     appliesTo: ["vowel", "consonant"],
@@ -151,12 +148,7 @@ const modifiers = {
     effects: { phonation: "breathy" }
   },
 
-  linguolabial: {
-    symbol: "̼",
-    appliesTo: "consonant",
-    effects: { placeModifier: "linguolabial" }
-  },
-
+  // HEIGHT MODIFICATION
   raised: {
     symbol: "̝",
     appliesTo: ["vowel", "consonant"],
@@ -168,6 +160,7 @@ const modifiers = {
     effects: { heightModifier: "lowered" }
   },
 
+  // TONGUE ROOT
   advanced_tongue_root: {
     symbol: "̘",
     appliesTo: "vowel",
@@ -179,8 +172,7 @@ const modifiers = {
     effects: { tongueRoot: "retracted" }
   },
 
-  // TONES / ACCENTS
-
+  // TONE (unified — removed pitch duplication)
   high_tone: {
     symbol: "́",
     appliesTo: ["vowel", "consonant"],
@@ -212,17 +204,6 @@ const modifiers = {
     effects: { tone: "extra-low" }
   },
 
-  extra_high_pitch: {
-    symbol: "᷄",
-    appliesTo: ["vowel", "consonant"],
-    effects: { pitch: "extra-high" }
-  },
-  extra_low_pitch: {
-    symbol: "᷅",
-    appliesTo: ["vowel", "consonant"],
-    effects: { pitch: "extra-low" }
-  },
-
   downstep: {
     symbol: "ꜜ",
     appliesTo: ["vowel", "consonant"],
@@ -239,12 +220,18 @@ const modifiers = {
     appliesTo: "consonant",
     effects: { release: "none" }
   },
-  //ejective
+
   ejective: {
-  symbol: "ʼ",
-  appliesTo: "consonant",
-  effects: { airstream: "egressive_glottalic" } // or just mark it as ejective
-}
+    symbol: "ʼ",
+    appliesTo: "consonant",
+    effects: { airstream: "egressive_glottalic" }
+  },
+
+  // SEQUENCE MODIFIERS
+  diphthong: { appliesTo: "sequence", effects: { type: "diphthong" } },
+  affricate: { appliesTo: "sequence", effects: { type: "affricate" } },
+  syllable: { appliesTo: "sequence", effects: { type: "syllable" } },
+  coarticulation: { appliesTo: "sequence", effects: { type: "coarticulation" } }
 };
 
 module.exports = modifiers;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ipa-core",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Language-agnostic IPA core with features",
   "repository": "github:Cody253/ipa-core",
   "homepage": "https://github.com/Cody253/ipa-core#readme",

package/parser.js

@@ -16,8 +16,14 @@ function parsePhoneme(base, appliedModifiers = []) {
     throw new Error(`Unknown base phoneme: ${base}`);
   }
 
-  let features = { ...baseObj.features };
-  const modifiersApplied = [];
+  // Start with type and airstream from core
+  let phoneme = {
+    base,
+    type: baseObj.type,          // consonant, vowel, etc.
+    airstream: baseObj.airstream, // pulmonic, egressive_glottalic, etc.
+    features: { ...baseObj.features },
+    modifiersApplied: []
+  };
 
   for (const modKey of appliedModifiers) {
     const mod = modifiers[modKey];
@@ -26,29 +32,25 @@ function parsePhoneme(base, appliedModifiers = []) {
     }
 
     const incompatible = rules[modKey]?.incompatibleWith || [];
-    const conflict = modifiersApplied.find(applied => incompatible.includes(applied));
+    const conflict = phoneme.modifiersApplied.find(applied => incompatible.includes(applied));
     if (conflict) {
       console.warn(`Modifier "${modKey}" is incompatible with already applied "${conflict}". Skipping.`);
       continue;
     }
 
-    if (mod.features) {
-      features = { ...features, ...mod.features };
+    if (mod.effects) {
+      phoneme.features = { ...phoneme.features, ...mod.effects };
     } else {
-      features[modKey] = true;
+      phoneme.features[modKey] = true;
     }
 
-    modifiersApplied.push(modKey);
+    phoneme.modifiersApplied.push(modKey);
   }
 
-  return {
-    base,
-    symbol: baseObj.symbol || base,
-    features,
-    modifiersApplied
-  };
+  return phoneme;
 }
 
+
 /**
  * Helper to create a phoneme unit for orthography config.
  * Can be a single phoneme or a sequence object.
@@ -56,10 +58,11 @@ function parsePhoneme(base, appliedModifiers = []) {
  * @param {string[]} appliedModifiers - Modifiers for single phoneme (ignored if sequence)
  * @returns {object}
  */
-function parseUnit(unit, appliedModifiers = []) {
+function parseUnit(unit, appliedModifiers = null) {
   // if unit is a string, treat as single phoneme
   if (typeof unit === "string") {
-    return { type: "single", base: unit, modifiers: appliedModifiers };
+    const mods = Array.isArray(appliedModifiers) ? appliedModifiers : [];
+    return { type: "single", base: unit, modifiers: mods };
   }
 
   // if unit is an object with multiple phonemes, treat as sequence
@@ -69,12 +72,79 @@ function parseUnit(unit, appliedModifiers = []) {
       const mods = unit[base] || [];
       sequence.push({ base, modifiers: mods });
     }
-    return { type: "sequence", sequence };
+    const type = (appliedModifiers && typeof appliedModifiers === "string") ? appliedModifiers : "sequence";
+    return { type, sequence };
   }
 
   throw new Error(`Invalid unit: ${unit}`);
 }
 
+/**
+ * Validates a sequence against its rules.
+ * @param {object} sequenceObj - { type, components }
+ * @returns {object} - validated sequence or throws error
+ */
+function validateSequence(sequenceObj) {
+  const { type, components } = sequenceObj;
+  const rule = rules[type];
+  
+  if (!rule) {
+    return sequenceObj;
+  }
+
+  if (rule.length && components.length !== rule.length) {
+    throw new Error(`${type} requires exactly ${rule.length} components, got ${components.length}`);
+  }
+
+  if (rule.minLength && components.length < rule.minLength) {
+    throw new Error(`${type} requires at least ${rule.minLength} components, got ${components.length}`);
+  }
+
+  if (rule.requires) {
+    for (const req of rule.requires) {
+      const component = components[req.position];
+      if (!component) {
+        throw new Error(`${type} requires component at position ${req.position}`);
+      }
+      if (req.type && component.type !== req.type) {
+        throw new Error(`${type} requires position ${req.position} to be type "${req.type}", got "${component.type}"`);
+      }
+      if (req.features) {
+        for (const [key, value] of Object.entries(req.features)) {
+          if (component.features[key] !== value) {
+            throw new Error(`${type} requires position ${req.position} to have features.${key}="${value}", got "${component.features[key]}"`);
+          }
+        }
+      }
+    }
+  }
+
+  if (rule.requiresAll) {
+    for (const req of rule.requiresAll) {
+      const invalid = components.find(c => req.type && c.type !== req.type);
+      if (invalid) {
+        throw new Error(`${type} requires all components to be type "${req.type}", but found "${invalid.type}"`);
+      }
+    }
+  }
+
+  if (rule.requiresFromPosition) {
+    for (const [pos, reqs] of Object.entries(rule.requiresFromPosition)) {
+      const component = components[parseInt(pos)];
+      if (!component) {
+        throw new Error(`${type} requires component at position ${pos}`);
+      }
+      for (const req of reqs) {
+        if (req.type && component.type !== req.type) {
+          throw new Error(`${type} requires position ${pos} to be type "${req.type}", got "${component.type}"`);
+        }
+      }
+    }
+  }
+
+  return sequenceObj;
+}
+
 /**
  * Parses a unit (single or sequence) into full feature objects
  * @param {object} unitObj
@@ -85,8 +155,14 @@ function parseUnitObj(unitObj) {
     return parsePhoneme(unitObj.base, unitObj.modifiers);
   }
 
-  if (unitObj.type === "sequence") {
-    return unitObj.sequence.map(u => parsePhoneme(u.base, u.modifiers));
+  if (unitObj.type === "sequence" || unitObj.type === "affricate" || unitObj.type === "diphthong" || unitObj.type === "syllable" || unitObj.type === "coarticulation") {
+    const components = unitObj.sequence.map((u, index) => {
+      const parsed = parsePhoneme(u.base, u.modifiers);
+      parsed.position = index;
+      return parsed;
+    });
+    const sequenceObj = { type: unitObj.type, components };
+    return validateSequence(sequenceObj);
   }
 
   throw new Error(`Unknown unit type: ${unitObj.type}`);
@@ -110,7 +186,7 @@ function parseConfig(config) {
     let unitObj;
 
     // Already a parseUnit object
-    if (val && typeof val === "object" && val.type && (val.type === "single" || val.type === "sequence")) {
+    if (val && typeof val === "object" && val.type && (val.type === "single" || val.sequence)) {
       unitObj = val;
     }
     // Shorthand single phoneme: ["base", ["modifiers"]]
@@ -119,10 +195,13 @@ function parseConfig(config) {
       const mods = Array.isArray(val[1]) ? val[1] : [];
       unitObj = { type: "single", base, modifiers: mods };
     }
-    // Shorthand sequence: [["base1", ["mods1"]], ["base2", ["mods2"]], ...]
-    else if (Array.isArray(val) && val.every(el => Array.isArray(el) && typeof el[0] === "string")) {
-      const sequence = val.map(([base, mods]) => ({ base, modifiers: Array.isArray(mods) ? mods : [] }));
-      unitObj = { type: "sequence", sequence };
+    // Shorthand sequence: [["base1", ["mods1"]], ["base2", ["mods2"]], ..., "affricate"]
+    else if (Array.isArray(val) && val.every(el => Array.isArray(el) || typeof el === "string")) {
+      const stringElements = val.filter(el => typeof el === "string");
+      const sequenceModifier = stringElements[0] || null;
+      const arrayElements = val.filter(el => Array.isArray(el));
+      const sequence = arrayElements.map(([base, mods]) => ({ base, modifiers: Array.isArray(mods) ? mods : [] }));
+      unitObj = { type: sequenceModifier || "sequence", sequence };
     }
     else {
       throw new Error(`Invalid orthography entry for "${letter}": ${JSON.stringify(val)}`);

package/rules.js

@@ -1,38 +1,45 @@
-//modifier compatability
+// modifier compatibility
 const rules = {
-  // Voicing / phonation
+  // VOICING / PHONATION
   voiceless: { incompatibleWith: ["voiced", "creaky_voice", "breathy_voice"] },
-  voiced: { incompatibleWith: ["voiceless", "voiceless_flap"] },
-  voiceless_flap: { incompatibleWith: ["voiced", "aspirated"] },
+  voiced: { incompatibleWith: ["voiceless"] },
   creaky_voice: { incompatibleWith: ["voiceless"] },
   breathy_voice: { incompatibleWith: ["voiceless"] },
 
-  // Place / articulation
-  advanced: { incompatibleWith: ["retracted", "velarized_or_pharyngealized"] },
-  retracted: { incompatibleWith: ["advanced", "velarized_or_pharyngealized"] },
-  palatalized: { incompatibleWith: ["velarized_or_pharyngealized"] },
-  velarized_or_pharyngealized: { incompatibleWith: ["palatalized", "advanced", "retracted"] },
-  pharyngealized: { incompatibleWith: ["palatalized"] },
-  linguolabial: { incompatibleWith: [] },
+  // PLACE: SHIFTS (mutually exclusive)
+  advanced: { incompatibleWith: ["retracted"] },
+  retracted: { incompatibleWith: ["advanced"] },
+
+  // PLACE: PRIMARY OVERRIDES
+  // (not inherently incompatible — last one wins in processing)
   dental: { incompatibleWith: [] },
-  apical: { incompatibleWith: [] },
-  laminal: { incompatibleWith: [] },
-  velarized: { incompatibleWith: ["palatalized", "advanced", "retracted"] },
+  linguolabial: { incompatibleWith: [] },
+
+  // TONGUE PART (mutually exclusive)
+  apical: { incompatibleWith: ["laminal"] },
+  laminal: { incompatibleWith: ["apical"] },
 
-  // Syllabicity
+  // SECONDARY ARTICULATION
+  // These can stack in real phonetics, but we constrain for clarity
+  palatalized: { incompatibleWith: ["velarized", "pharyngealized"] },
+  velarized: { incompatibleWith: ["palatalized"] },
+  pharyngealized: { incompatibleWith: ["palatalized"] },
+  labialized: { incompatibleWith: [] },
+
+  // SYLLABICITY
   syllabic: { incompatibleWith: ["non_syllabic"] },
   non_syllabic: { incompatibleWith: ["syllabic"] },
 
-  // Nasalization / rhoticity
+  // NASALIZATION / RHOTICITY
   nasalized: { incompatibleWith: [] },
   rhoticity: { incompatibleWith: [] },
 
-  // Length / duration
+  // LENGTH / DURATION
   extra_short: { incompatibleWith: ["length_half_long", "length_long"] },
   length_half_long: { incompatibleWith: ["extra_short", "length_long"] },
   length_long: { incompatibleWith: ["extra_short", "length_half_long"] },
 
-  // Segment-level tones / accents
+  // TONE
   high_tone: { incompatibleWith: ["low_tone", "falling_tone", "extra_low_tone"] },
   low_tone: { incompatibleWith: ["high_tone", "rising_tone", "extra_high_tone"] },
   rising_tone: { incompatibleWith: ["falling_tone", "low_tone"] },
@@ -41,12 +48,63 @@ const rules = {
   extra_low_tone: { incompatibleWith: ["extra_high_tone", "high_tone"] },
   downstep: { incompatibleWith: [] },
   upstep: { incompatibleWith: [] },
-  extra_high_pitch: { incompatibleWith: ["extra_low_pitch"] },
-  extra_low_pitch: { incompatibleWith: ["extra_high_pitch"] },
 
-  // Special consonant markers
-  aspirated: { incompatibleWith: ["voiceless_flap", "no_audible_release"] },
-  no_audible_release: { incompatibleWith: ["aspirated"] }
+  // RELEASE / ASPIRATION
+  aspirated: { incompatibleWith: ["no_audible_release"] },
+  no_audible_release: { incompatibleWith: ["aspirated"] },
+
+    // VOWEL QUALITY (non-conflicting dimensions)
+  more_rounded: { incompatibleWith: [] },
+  less_rounded: { incompatibleWith: [] },
+
+  centralized: { incompatibleWith: ["mid_centralized"] },
+  mid_centralized: { incompatibleWith: ["centralized"] },
+
+  raised: { incompatibleWith: ["lowered"] },
+  lowered: { incompatibleWith: ["raised"] },
+
+  // TONGUE ROOT (single axis, but isolated from others)
+  advanced_tongue_root: { incompatibleWith: ["retracted_tongue_root"] },
+  retracted_tongue_root: { incompatibleWith: ["advanced_tongue_root"] },
+
+  // AIRSTREAM MECHANISM (independent feature class)
+  ejective: { incompatibleWith: [] },
+
+  // SEQUENCE-LEVEL RULES
+
+  affricate: {
+    requires: [
+      { position: 0, features: { manner: "plosive" } },
+      { position: 1, features: { manner: "fricative" } }
+    ],
+    length: 2
+  },
+
+  diphthong: {
+    requiresAll: [
+      { type: "vowel" }
+    ],
+    minLength: 2
+  },
+
+  coarticulation: {
+    requiresAll: [
+      { type: "consonant" }
+    ],
+    minLength: 2
+  },
+
+  syllable: {
+    requires: [
+      { position: 0, type: "consonant" }
+    ],
+    requiresFromPosition: {
+      1: [
+        { type: "vowel" }
+      ]
+    },
+    minLength: 2
+  }
 };
 
-module.exports = rules
+module.exports = rules;

package/test.js

@@ -1,6 +1,7 @@
 // test.js
 
 const { parseUnit, parseConfig } = require("./parser");
+const { getDefinitions } = require("./get-definitions");
 
 // Sample orthography config
 const orthography = {
@@ -14,25 +15,57 @@ const orthography = {
   x̱: parseUnit({
     k: ["ejective", "aspirated"],
     x: []
-  }),
+  }, "affricate"),
 
   // Another single consonant
-  l: parseUnit("ɬ")
+  l: parseUnit("ɬ"),
+
+  // Consonant with place modifiers
+  t̪: parseUnit("t", ["dental"]),
+  s̻: parseUnit("s", ["laminal"]),
+  k̠: parseUnit("k", ["retracted"])
 };
 
 // Another sample orthography config using shorthand
 const shorthandOrthography = {
-  // A single consonant with a modifier
-  k: ["k", ["aspirated"]],
+  // A single consonant
+  k: ["k"],
 
   // A single vowel with a modifier
   a: ["ɑ", ["more_rounded"]],
 
-  // A consonant sequence (affricate)
-  x̱: [[
-    'k', ["ejective", "aspirated"],
-    'x', []
-]],
+  // A consonant sequence (affricate) with new string shorthand
+  x̱: [
+    ["k", ["ejective", "aspirated"]],
+    ["x", []],
+    "affricate"
+  ],
+
+  // Diphthong example
+  ai: [
+    ["ɑ"],
+    ["i"],
+    "diphthong"
+  ],
+
+  // Syllable example (e.g., CV - consonant followed by vowel)
+  na: [
+    ["n"],
+    ["ɑ"],
+    "syllable"
+  ],
+
+  // Coarticulation example (e.g., labial-velar)
+  w: [
+    ["ʍ"],
+    "coarticulation"
+  ],
+
+  // Plain sequence (no sequence modifier)
+  kl: [
+    ["k"],
+    ["l"]
+  ],
 
   // Another single consonant
   l: ["ɬ"]
@@ -48,13 +81,26 @@ console.log(JSON.stringify(parsed, null, 2));
 // Optional: inspect a single phoneme
 const singlePhoneme = parsed.k;
 console.log("\n=== Single Phoneme 'k' Features ===");
-console.log(singlePhoneme);
+console.log(JSON.stringify(singlePhoneme, null, 2));
 
 // Optional: inspect a sequence
 const affricateSequence = parsed.x̱;
 console.log("\n=== Affricate Sequence 'x̱' Features ===");
-console.log(affricateSequence);
+console.log(JSON.stringify(affricateSequence, null, 2));
+
+// const parsedShorthand = parseConfig(shorthandOrthography);
+// console.log("\n=== Parsed Output2 ===");
+// console.log(JSON.stringify(parsedShorthand, null, 2));
+
+// Definitions
+
+
+console.log("\n=== Definitions for 'k' ===");
+console.log(getDefinitions(parsed.k));
+
+console.log("\n=== Definitions for 'x̱' (affricate) ===");
+console.log(getDefinitions(parsed.x̱));
+
+console.log("\n=== Definitions for 'a' (vowel) ===");
+console.log(getDefinitions(parsed.a));
 
-const parsedShorthand = parseConfig(shorthandOrthography);
-console.log("\n=== Parsed Output2 ===");
-console.log(JSON.stringify(parsedShorthand, null, 2));