Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

CJK-REVERT2: withdraw speculative spacing rules and narrow import rejection

Shao Wenbin9f655739fab0
diff --git a/ROADMAP.md b/ROADMAP.md
index 27d2e8928..eef038e6a 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,10 +1,9 @@
# DesignCraft roadmap
-- CJK-MOJI8: preserve shaped narrow punctuation and manual Tsume instead of restoring nonexistent full-width blank space.
-- CJK-MOJI7: reject malformed Mojikumi interchange values and check nested note/cell paragraph rules in preflight.
-- CJK-MOJI6: apply spacing at shaped-cluster boundaries and distinguish centered Traditional Chinese punctuation from Simplified Chinese side bearings.
+- CJK-MOJI8: preserve shaped narrow punctuation when tracking changes its advance.
+- CJK-MOJI7: prevent numeric coercion in Mojikumi import, preserve finite unsupported rules, and check nested note/cell rules in preflight.
+- CJK-MOJI6: apply spacing at shaped-cluster boundaries without moving attached marks.
- CJK-MOJI5: share equal-priority boundary spacing and honor discrete compression endpoints, including leading-only ragged-line fitting.
-- CJK-MOJI4: resolve all public Mojikumi preset names and their distinct paragraph/line-edge policies; correct consecutive punctuation defaults and small-kana classes.
- CJK-MOJI3: use the composition rule resolver in preflight, report unknown Mojikumi presets and retain regression coverage for supported and unsupported settings.
diff --git a/crates/compose/src/mojikumi.rs b/crates/compose/src/mojikumi.rs
index 0c44e546e..a1ca09c9e 100644
--- a/crates/compose/src/mojikumi.rs
+++ b/crates/compose/src/mojikumi.rs
@@ -10,8 +10,6 @@ pub struct Metrics {
pub active: bool,
/// Shaped body width before tracking and manual character spacing.
pub body: f64,
- pub tsume_before: f64,
- pub tsume_after: f64,
pub blank_before: f64,
pub blank_after: f64,
/// Desired internal gap attached to this glyph's advance.
@@ -71,8 +69,8 @@ pub fn apply(glyphs: &mut [Glyph], styles: &Styles, name: &str) {
// Tracking must not make a proportional or half-width glyph appear to
// contain a removable half-em body. Shaping features already affect body.
if body >= unit * 0.8 {
- let before = if cluster[0].moji.explicit_before { 0.0 } else { (table.leading(class) * unit - cluster[0].moji.tsume_before).max(0.0) };
- let after = if cluster[0].moji.explicit_after { 0.0 } else { (table.trailing(class) * unit - cluster[0].moji.tsume_after).max(0.0) };
+ let before = if cluster[0].moji.explicit_before { 0.0 } else { rules::leading(class) * unit };
+ let after = if cluster[0].moji.explicit_after { 0.0 } else { rules::trailing(class) * unit };
let trim = before + after;
if let Some(owner) = cluster.iter().position(|g| g.adv >= trim) {
cluster[0].moji.blank_before = before / unit.max(1e-9);
diff --git a/crates/compose/src/shape.rs b/crates/compose/src/shape.rs
index bbf91cbb8..e1d46aa25 100644
--- a/crates/compose/src/shape.rs
+++ b/crates/compose/src/shape.rs
@@ -477,8 +477,6 @@ fn shape_run(
let tsume = p.tsume.clamp(0.0, 1.0);
let before = p.leading_aki.unwrap_or(0.0).clamp(0.0, 100.0) * em;
let after = p.trailing_aki.unwrap_or(0.0).clamp(0.0, 100.0) * em;
- g.moji.tsume_before = left * tsume;
- g.moji.tsume_after = right * tsume;
g.dx += before - left * tsume;
g.adv += before + after - (left + right) * tsume;
}
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 33e0c7a9a..32e0e90cf 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -706,8 +706,8 @@ impl Document {
}
}
for t in &self.styles.mojikumi_tables {
- if t.overrides.iter().any(|r| !mojikumi::valid_range(r)) {
- return Err(DocError::Invalid(format!("invalid mojikumi spacing: {}", t.name)));
+ if t.overrides.iter().any(|r| ![r.minimum, r.desired, r.maximum].iter().all(|v| v.is_finite())) {
+ return Err(DocError::Invalid(format!("non-finite mojikumi spacing: {}", t.name)));
}
}
let mut ids = std::collections::HashSet::new();
diff --git a/crates/doc/src/mojikumi.rs b/crates/doc/src/mojikumi.rs
index aaedd355a..fbb8a13df 100644
--- a/crates/doc/src/mojikumi.rs
+++ b/crates/doc/src/mojikumi.rs
@@ -19,92 +19,9 @@ impl Aki {
}
}
-/// Adobe's public 16-preset enumeration. Japanese preset geometry is described
-/// in the Adobe Mojikumi guide, sections 3.1–3.14 (see docs/mojikumi.md).
-#[derive(Clone, Copy, Debug)]
-struct Preset(u8);
-impl Preset {
- fn parse(name: &str) -> Option<Self> {
- let name = name.trim_start_matches("$ID/");
- let names = [
- "LineEndAllOneHalfEmEnum",
- "OneEmIndentLineEndUkeOneHalfEmEnum",
- "OneOrOneHalfEmIndentLineEndUkeOneHalfEmEnum",
- "OneOrOneHalfEmIndentLineEndAllOneEmEnum",
- "OneEmIndentLineEndAllOneEmEnum",
- "OneEmIndentLineEndAllNoFloatEnum",
- "OneEmIndentLineEndUkeNoFloatEnum",
- "OneOrOneHalfEmIndentLineEndUkeNoFloatEnum",
- "OneEmIndentLineEndAllOneHalfEmEnum",
- "LineEndAllOneEmEnum",
- "LineEndUkeNoFloatEnum",
- "OneOrOneHalfEmIndentLineEndPeriodOneEmEnum",
- "OneEmIndentLineEndPeriodOneEmEnum",
- "LineEndPeriodOneEmEnum",
- "TradChineseDefault",
- "SimpChineseDefault",
- ];
- names.iter().position(|n| *n == name).map(|i| Self(i as u8 + 1)).or_else(|| {
- let n = name.strip_prefix("kMojikumiDefaultName")?.parse::<u8>().ok()?;
- (1..=16).contains(&n).then_some(Self(n))
- })
- }
- fn leading(self, c: i16) -> f64 {
- if self.0 == 15 && matches!(c, 6 | 21 | 30 | 31) {
- 0.25
- } else if self.0 == 16 && c == 32 {
- 0.0
- } else {
- leading(c)
- }
- }
- fn trailing(self, c: i16) -> f64 {
- if self.0 == 15 && matches!(c, 6 | 21 | 30 | 31) {
- 0.25
- } else if self.0 == 16 && c == 32 {
- 0.5
- } else {
- trailing(c)
- }
- }
- fn boundary(self, left: i16, right: i16) -> Option<Aki> {
- let n = self.0;
- let open = |c| matches!(c, 1 | 26 | 27);
- if left == 23 {
- if n >= 15 {
- return Some(Aki::fixed(self.leading(right)));
- }
- let indent = if matches!(n, 1 | 10 | 11 | 14) { 0.0 } else { 1.0 };
- let opening = match n {
- 2 | 5 | 7 | 13 => 1.5,
- 3 | 8 | 10 => 0.5,
- 4 | 6 | 9 | 12 => 1.0,
- _ => 0.0,
- };
- return Some(Aki::fixed(if open(right) { opening } else { indent + self.leading(right) }));
- }
- if left == 22 {
- return Some(Aki::fixed(if n >= 15 || matches!(n, 4 | 5 | 10) { self.leading(right) } else { 0.0 }));
- }
- if right == 22 {
- let width = self.trailing(left);
- let full = n >= 15 || matches!(n, 4 | 5 | 10) || (matches!(n, 12..=14) && matches!(left, 6 | 31));
- let discrete = n == 6 || (matches!(n, 7 | 8 | 11) && matches!(left, 2 | 6 | 21 | 28..=31));
- return Some(if full {
- Aki::fixed(width)
- } else if discrete {
- Aki { min: 0.0, desired: width, max: width, priority: 1, discrete: true }
- } else {
- Aki::fixed(0.0)
- });
- }
- None
- }
-}
-
/// Resolved table; custom rows override the base preset in document order.
pub struct Rules<'a> {
- preset: Preset,
+ chinese: bool,
rows: &'a [MojikumiAki],
}
impl<'a> Rules<'a> {
@@ -115,25 +32,25 @@ impl<'a> Rules<'a> {
let key = name.strip_prefix("MojikumiTable/").unwrap_or(name);
let table = styles.mojikumi_tables.iter().find(|t| t.name == key);
let base = table.map_or(key, |t| if t.based_on.is_empty() { t.name.as_str() } else { t.based_on.as_str() });
- let preset = Preset::parse(base).ok_or_else(|| format!("unknown base preset `{base}`"))?;
+ let chinese = match base.trim_start_matches("$ID/") {
+ "SimpChineseDefault" | "TradChineseDefault" => true,
+ "LineEndAllOneHalfEmEnum" | "kMojikumiDefaultName1" => false,
+ _ => return Err(format!("unknown base preset `{base}`")),
+ };
let rows = table.map_or(&[][..], |t| t.overrides.as_slice());
for r in rows {
if !valid_class(r.target_class) || !valid_class(r.side_class) {
return Err(format!("unsupported character classes {}/{}", r.target_class, r.side_class));
}
- if !valid_range(r) {
+ if ![r.minimum, r.desired, r.maximum].iter().all(|v| v.is_finite() && (-1.0..=100.0).contains(v))
+ || r.minimum > r.desired
+ || r.desired > r.maximum
+ || !(0..=9).contains(&r.priority)
+ {
return Err("invalid spacing range or priority".into());
}
}
- Ok(Some(Self { preset, rows }))
- }
-
- /// Blank body portions for the preset's regional punctuation convention.
- pub fn leading(&self, class: i16) -> f64 {
- self.preset.leading(class)
- }
- pub fn trailing(&self, class: i16) -> f64 {
- self.preset.trailing(class)
+ Ok(Some(Self { chinese, rows }))
}
fn override_pair(&self, left: i16, right: i16) -> Option<&MojikumiAki> {
@@ -149,11 +66,11 @@ impl<'a> Rules<'a> {
let mut aki = self.pair(left, right);
if self.override_pair(left, right).is_none() {
let missing = if matches!(left, 22 | 23) {
- self.leading(right) - before_right
+ leading(right) - before_right
} else if right == 22 {
- self.trailing(left) - after_left
+ trailing(left) - after_left
} else {
- self.trailing(left).max(self.leading(right)) - after_left.max(before_right)
+ trailing(left).max(leading(right)) - after_left.max(before_right)
}
.max(0.0);
aki.min = (aki.min - missing).max(0.0);
@@ -173,17 +90,15 @@ impl<'a> Rules<'a> {
discrete: row.does_not_float,
};
}
- if let Some(aki) = self.preset.boundary(left, right) {
- return aki;
+ // Boundaries: Chinese keeps full punctuation; the half-em Japanese set
+ // trims opening punctuation at line start and closing punctuation at end.
+ if matches!(left, 22 | 23) {
+ return Aki::fixed(if self.chinese { leading(right) } else { 0.0 });
}
- // Adjacent opening brackets and adjacent closing punctuation share a
- // half-body, rather than restoring both glyphs to their full widths.
- if (matches!(left, 1 | 26 | 27) && matches!(right, 1 | 26 | 27))
- || (matches!(left, 2 | 6 | 21 | 28..=31) && matches!(right, 2 | 6 | 21 | 28..=31))
- {
- return Aki::fixed(0.0);
+ if right == 22 {
+ return Aki::fixed(if self.chinese { trailing(left) } else { 0.0 });
}
- let punctuation = self.trailing(left).max(self.leading(right));
+ let punctuation = trailing(left).max(leading(right));
if punctuation > 0.0 {
return Aki { min: 0.0, desired: punctuation, max: punctuation, priority: 1, discrete: false };
}
@@ -199,15 +114,6 @@ impl<'a> Rules<'a> {
}
}
-/// Structural validation shared by native document loading and interchange.
-/// Unknown integer classes remain preservable and are diagnosed by the resolver.
-pub fn valid_range(r: &MojikumiAki) -> bool {
- [r.minimum, r.desired, r.maximum].iter().all(|v| v.is_finite() && (-1.0..=100.0).contains(v))
- && r.minimum <= r.desired
- && r.desired <= r.maximum
- && (0..=9).contains(&r.priority)
-}
-
pub fn valid_class(c: i16) -> bool {
matches!(c, 1..=12 | 18 | 21..=33)
}
@@ -247,42 +153,13 @@ pub fn class(c: char) -> i16 {
'¥' | '$' | '£' | '¥' => 8,
'%' | '‰' | '℃' | '°' => 9,
'\u{3000}' => 10,
- 'ゕ'
- | 'ゖ'
- | 'ヵ'
- | 'ヶ'
- | '\u{31f0}'..='\u{31ff}'
- | 'ぁ'
- | 'ぃ'
- | 'ぅ'
- | 'ぇ'
- | 'ぉ'
- | 'っ'
- | 'ゃ'
- | 'ゅ'
- | 'ょ'
- | 'ゎ'
- | 'ァ'
- | 'ィ'
- | 'ゥ'
- | 'ェ'
- | 'ォ'
- | 'ッ'
- | 'ャ'
- | 'ュ'
- | 'ョ'
- | 'ヮ'
- | 'ー'
- | '々'
- | 'ゝ'
- | 'ゞ'
- | 'ヽ'
- | 'ヾ' => 3,
+ 'ぁ' | 'ぃ' | 'ぅ' | 'ぇ' | 'ぉ' | 'っ' | 'ゃ' | 'ゅ' | 'ょ' | 'ゎ' | 'ァ' | 'ィ' | 'ゥ' | 'ェ' | 'ォ' | 'ッ' | 'ャ' | 'ュ' | 'ョ' | 'ヮ'
+ | 'ー' | '々' | 'ゝ' | 'ゞ' | 'ヽ' | 'ヾ' => 3,
'\u{3040}'..='\u{309f}' => 11,
- '\u{30a0}'..='\u{30ff}' | '\u{ff66}'..='\u{ff9d}' => 33,
+ '\u{30a0}'..='\u{30ff}' | '\u{31f0}'..='\u{31ff}' => 33,
'0'..='9' => 24,
'0'..='9' => 25,
- '\u{2e80}'..='\u{a4cf}' | '\u{ac00}'..='\u{d7af}' | '\u{f900}'..='\u{faff}' | '\u{ff01}'..='\u{ff60}' | '\u{20000}'..='\u{3347f}' => 12,
+ '\u{2e80}'..='\u{a4cf}' | '\u{ac00}'..='\u{d7af}' | '\u{f900}'..='\u{faff}' | '\u{ff01}'..='\u{ff60}' | '\u{20000}'..='\u{323af}' => 12,
_ => 18,
}
}
@@ -292,47 +169,6 @@ mod tests {
use super::*;
use crate::cjk::MojikumiTable;
- #[test]
- fn regional_punctuation_retains_the_correct_side_bearings() {
- let styles = Styles::default();
- let traditional = Rules::resolve(&styles, "TradChineseDefault").unwrap().unwrap();
- let simplified = Rules::resolve(&styles, "SimpChineseDefault").unwrap().unwrap();
- assert_eq!(traditional.leading(class('。')), 0.25);
- assert_eq!(traditional.trailing(class('。')), 0.25);
- assert_eq!(simplified.leading(class('。')), 0.0);
- assert_eq!(simplified.trailing(class('。')), 0.5);
- assert_eq!(traditional.pair(12, class('。')).desired, 0.25);
- assert_eq!(simplified.pair(12, class('。')).desired, 0.0);
- assert_eq!(simplified.leading(class(':')), 0.0);
- assert_eq!(simplified.trailing(class(':')), 0.5);
- assert!((simplified.pair_with_bodies(6, 12, 0.1, 0.0).desired - 0.1).abs() < 1e-9);
- assert_eq!(simplified.pair_with_bodies(22, 27, 0.0, 0.0).desired, 0.0);
- }
-
- #[test]
- fn all_public_presets_have_distinct_documented_edges() {
- let styles = Styles::default();
- let openings = [0.0, 1.5, 0.5, 1.0, 1.5, 1.0, 1.5, 0.5, 1.0, 0.5, 0.0, 1.0, 1.5, 0.0];
- for (i, expected) in openings.into_iter().enumerate() {
- let rules = Rules::resolve(&styles, &format!("$ID/kMojikumiDefaultName{}", i + 1)).unwrap().unwrap();
- assert_eq!(rules.pair(23, 26).desired, expected, "preset {}", i + 1);
- assert_eq!(rules.pair(23, 12).desired, if matches!(i + 1, 1 | 10 | 11 | 14) { 0.0 } else { 1.0 });
- }
- let discrete = Rules::resolve(&styles, "OneEmIndentLineEndUkeNoFloatEnum").unwrap().unwrap();
- assert!(discrete.pair(6, 22).discrete);
- assert!(!discrete.pair(5, 22).discrete);
- let period = Rules::resolve(&styles, "LineEndPeriodOneEmEnum").unwrap().unwrap();
- assert_eq!(period.pair(6, 22).desired, 0.5);
- assert_eq!(period.pair(21, 22).desired, 0.0);
- for name in ["$ID/kMojikumiDefaultName15", "$ID/kMojikumiDefaultName16"] {
- assert!(Rules::resolve(&styles, name).unwrap().is_some());
- }
- assert_eq!(period.pair(26, 26).desired, 0.0);
- assert_eq!(period.pair(28, 6).desired, 0.0);
- assert_eq!(class('ㇰ'), 3);
- assert_eq!(class('カ'), 33);
- }
-
#[test]
fn overrides_are_directional_and_unknown_tables_are_not_silently_applied() {
let mut styles = Styles::default();
@@ -352,7 +188,6 @@ mod tests {
});
let rule = Rules::resolve(&styles, "MojikumiTable/Pair").unwrap().unwrap();
assert_eq!(rule.pair(18, 12).desired, 0.2);
- assert_eq!(rule.pair_with_bodies(18, 12, 0.0, 0.0).desired, 0.2);
assert_eq!(rule.pair(12, 18).desired, 0.25);
assert!(Rules::resolve(&styles, "Unknown").is_err());
assert!(Rules::resolve(&styles, "Nothing").unwrap().is_none());
diff --git a/crates/idml/src/import.rs b/crates/idml/src/import.rs
index 932062724..fba7ae665 100644
--- a/crates/idml/src/import.rs
+++ b/crates/idml/src/import.rs
@@ -144,14 +144,14 @@ fn lab_to_color(l: f32, a: f32, b: f32) -> Color {
}
fn mojikumi_row(e: &El) -> Result<designcraft_doc::cjk::MojikumiAki> {
- let number = |key: &str, required: bool| -> Result<f64> {
+ let number = |key: &str| -> Result<f64> {
let Some(raw) = e.prop(key) else {
- return if required { Err(IdmlError::Invalid(format!("Mojikumi row is missing {key}"))) } else { Ok(0.0) };
+ return Ok(0.0);
};
raw.trim().parse::<f64>().ok().filter(|v| v.is_finite()).ok_or_else(|| IdmlError::Invalid(format!("Mojikumi row has invalid {key}")))
};
- let integer = |key: &str, required: bool| -> Result<i16> {
- let v = number(key, required)?;
+ let integer = |key: &str| -> Result<i16> {
+ let v = number(key)?;
if v.fract() != 0.0 || v < f64::from(i16::MIN) || v > f64::from(i16::MAX) {
return Err(IdmlError::Invalid(format!("Mojikumi {key} must be an in-range integer")));
}
@@ -165,18 +165,15 @@ fn mojikumi_row(e: &El) -> Result<designcraft_doc::cjk::MojikumiAki> {
}
};
let row = designcraft_doc::cjk::MojikumiAki {
- target_class: integer("TargetMojikumiClass", true)?,
- side_class: integer("SideMojikumiClass", true)?,
+ target_class: integer("TargetMojikumiClass")?,
+ side_class: integer("SideMojikumiClass")?,
after: boolean("SideIsAfterTarget")?,
- minimum: number("Minimum", false)?,
- desired: number("Desired", false)?,
- maximum: number("Maximum", false)?,
- priority: integer("CompressionPriority", false)?,
+ minimum: number("Minimum")?,
+ desired: number("Desired")?,
+ maximum: number("Maximum")?,
+ priority: integer("CompressionPriority")?,
does_not_float: boolean("AkiDoesNotFloat")?,
};
- if !designcraft_doc::mojikumi::valid_range(&row) {
- return Err(IdmlError::Invalid("Mojikumi row has an invalid spacing range or priority".into()));
- }
Ok(row)
}
diff --git a/crates/idml/src/tests.rs b/crates/idml/src/tests.rs
index 79f242483..11fb11b8b 100644
--- a/crates/idml/src/tests.rs
+++ b/crates/idml/src/tests.rs
@@ -947,6 +947,7 @@ fn malformed_mojikumi_rows_are_not_silently_coerced() {
("Desired", "oops"),
("Minimum", "0.4"),
("Maximum", "0.1"),
+ ("Maximum", "101"),
("CompressionPriority", "10"),
("AkiDoesNotFloat", "maybe"),
] {
@@ -964,7 +965,17 @@ fn malformed_mojikumi_rows_are_not_silently_coerced() {
("Spreads/Spread_sp1.xml", SPREAD),
("Stories/Story_s1.xml", STORY),
]);
- let err = import_idml(&bytes).unwrap_err().to_string();
- assert!(err.contains("Mojikumi"), "{key}={value}: {err}");
+ if matches!((key, value), ("Minimum", "0.4") | ("Maximum", "0.1" | "101") | ("CompressionPriority", "10")) {
+ // Finite, representable rules survive import even if composition
+ // cannot apply them. The resolver supplies a diagnostic instead.
+ let document = import_idml(&bytes).unwrap();
+ document.check().unwrap();
+ assert!(designcraft_doc::mojikumi::Rules::resolve(&document.styles, "MojikumiTable/Bad").is_err());
+ let restored = import_idml(&export_idml(&document)).unwrap();
+ assert_eq!(restored.styles.mojikumi_tables, document.styles.mojikumi_tables);
+ } else {
+ let err = import_idml(&bytes).unwrap_err().to_string();
+ assert!(err.contains("Mojikumi"), "{key}={value}: {err}");
+ }
}
}
diff --git a/docs/mojikumi.md b/docs/mojikumi.md
index c9390d58d..fcdf28074 100644
--- a/docs/mojikumi.md
+++ b/docs/mojikumi.md
@@ -1,33 +1,18 @@
-# Mojikumi implementation and public references
+# Mojikumi repair scope
-This is a clean-room implementation of public spacing behavior. Mojikumi is an
-Adobe feature, not a single conformance standard. W3C JLReq and CLReq describe
-Japanese and Chinese layout requirements; they do not specify Adobe's private
-composer or its complete preset pair matrices.
+The retained changes address reproducible implementation defects: equal-priority
+spacing allocation, discrete compression endpoints, leading-only compression,
+spacing after complete shaped clusters, and tracking that made narrow punctuation
+look full-width. Preflight also checks nested note and table-cell paragraph rules.
-References:
+IDML import rejects malformed/non-finite numbers and integer coercion. Finite,
+representable rules outside the composer's supported range remain preserved;
+the rule resolver reports unsupported settings instead of rejecting the document.
-- [Adobe preset enumeration](https://developer.adobe.com/indesign/uxp/dom/api/m/mojikumi-table-defaults/)
-- [Adobe Mojikumi guide, sections 3–5](https://wwwimages.adobe.com/www.adobe.com/jp/joc/design/guides/pdf/mojikumi.pdf)
-- [Adobe spacing priorities](https://helpx.adobe.com/indesign/desktop/language-and-proofing/chinese-japanese-and-korean/set-spacing-priorities-in-mojikumi-character-classes.html)
-- [W3C JLReq](https://www.w3.org/TR/jlreq/), especially character classes and line adjustment
-- [W3C CLReq](https://www.w3.org/TR/clreq/), especially regional punctuation placement
+The broad preset expansion, regional side-bearing changes, Tsume combination
+policy, and CID preference/diagnostic extension were withdrawn after review.
+The original supported preset set and Unicode classification remain in place.
+No claim of full Adobe Mojikumi conformance or exact output parity is made.
-## Presets and interchange
-
-The resolver recognizes the 14 Japanese presets and two Chinese presets from the
-public enumeration, including their IDML resource aliases. Paragraph indentation,
-opening-bracket indentation, ordinary line starts, full/half/discrete line ends,
-and period-only line-end policies are represented separately. Custom IDML rows
-replace the corresponding directional pair. Adjacent opening and closing marks
-must not regain two full blank half-bodies.
-
-Regression tests cover preset boundary differences, custom override precedence,
-IDML reference round trips, and unsupported names. The implementation must not be
-represented as a byte-for-byte reproduction of Adobe's full preset matrices.
-
-## Audit work
-
-Further audit areas are regional punctuation metrics, shaped cluster boundaries,
-equal-priority allocation, discrete line fitting, input validation, and diagnostics
-for compatibility modes whose glyph classification cannot yet be reproduced.
+Reference for priority semantics:
+[Adobe spacing priorities](https://helpx.adobe.com/indesign/desktop/language-and-proofing/chinese-japanese-and-korean/set-spacing-priorities-in-mojikumi-character-classes.html).