calliope-ts 0.0.4 → 0.1.0

package/dist/display.d.ts

@@ -1,5 +1,19 @@
 import { ClsWord, LineResult } from './types.js';
-export declare function renderUnifiedDisplay(result: LineResult, rawLine?: string): string;
+import { type FHSyllable } from './fabbhalle.js';
+/** The Fabb–Halle projection of a line — one FHSyllable per syllable of every
+ *  non-punctuation word, carrying LEXICAL stress only.  Exported so the CLI
+ *  can run F&H's poem-level rule-set discovery over a whole document before
+ *  rendering (only lex/poly matter for discovery; text is cosmetic). */
+export declare function fabbHalleSyllablesOf(result: LineResult): FHSyllable[];
+export interface RenderOptions {
+    /** Rule set discovered by F&H's own poem-level grid construction
+     *  (buildFabbHalleGridsForPoem over the whole document).  When present,
+     *  the F&H section scans under it and reports agreement with the engine's
+     *  verdict; when absent, the section falls back to stipulating the
+     *  engine's meter (legacy single-line behaviour). */
+    fhSchema?: string | null;
+}
+export declare function renderUnifiedDisplay(result: LineResult, rawLine?: string, opts?: RenderOptions): string;
 export declare function renderLegend(): string;
 /**
  * The long-form legend triggered from the main menu's "Display Legend" option:

package/dist/display.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../src/display.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,OAAO,EAMP,UAAU,EAGX,MAAM,YAAY,CAAC;AAgNpB,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAySjF;AAMD,wBAAgB,YAAY,IAAI,MAAM,CAUrC;AAuHD;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAsBzC;AAqCD,4DAA4D;AAC5D,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB;AAmCD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAuC/E;AA2OD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM,CA0FlE"}
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../src/display.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,OAAO,EAMP,UAAU,EAGX,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA8MrE;;;wEAGwE;AACxE,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,EAAE,CAerE;AAED,MAAM,WAAW,aAAa;IAC5B;;;;yDAIqD;IACrD,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,MAAM,CAwXvG;AAMD,wBAAgB,YAAY,IAAI,MAAM,CAUrC;AAuHD;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAsBzC;AAqCD,4DAA4D;AAC5D,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB;AAmCD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAuC/E;AA2OD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM,CA0FlE"}

package/dist/display.js

@@ -3,6 +3,7 @@
 import chalk from 'chalk';
 import { isPunctuation } from './parser.js';
 import { syllabifyWord, syllableVowelLengths } from './phonological.js';
+import { buildFabbHalleGrid } from './fabbhalle.js';
 import { computeCaesurae } from './caesura.js';
 import { computeBoundaries } from './calliope/boundaries.js';
 import { summarizePoem, analyzePhonopoetics } from './rhyme.js';
@@ -171,7 +172,28 @@ function buildColSyls(words, ius) {
 // ═══════════════════════════════════════════════════════════════════════
 // UNIFIED DISPLAY — All layers integrated
 // ═══════════════════════════════════════════════════════════════════════
-export function renderUnifiedDisplay(result, rawLine) {
+/** The Fabb–Halle projection of a line — one FHSyllable per syllable of every
+ *  non-punctuation word, carrying LEXICAL stress only.  Exported so the CLI
+ *  can run F&H's poem-level rule-set discovery over a whole document before
+ *  rendering (only lex/poly matter for discovery; text is cosmetic). */
+export function fabbHalleSyllablesOf(result) {
+    const out = [];
+    for (const w of result.sentence.words) {
+        if (isPunctuation(w.lexicalClass))
+            continue;
+        const poly = w.syllables.length > 1;
+        // Monosyllabic FUNCTION words are clitics with no lexical stress in
+        // F&H's sense (condition (16): a maximum's neighbours must "not carry
+        // lexical stress" — "were", "in", "like" never block a maximum, while
+        // content monosyllables like "wolf" legitimately do).
+        const cliticMono = !poly && !w.isContent;
+        for (const s of w.syllables) {
+            out.push({ text: s.text, lex: cliticMono ? 0 : (s.lexicalStress ?? s.stress ?? 0), poly });
+        }
+    }
+    return out;
+}
+export function renderUnifiedDisplay(result, rawLine, opts) {
     const words = result.sentence.words;
     const ius = result.phonologicalHierarchy;
     const detail = result.phonologicalScansion;
@@ -445,18 +467,98 @@ export function renderUnifiedDisplay(result, rawLine) {
     lines.push('  ' + H2('Scansion: ') + detail.scansion);
     lines.push('  ' + H2('Summary:  ') + detail.summary);
     lines.push('');
-    // ── Layer 9: Scandroid comparison (if available) ────────────────
-    if (result.scandroidCorral || result.scandroidMaximise) {
-        lines.push(H1('Scandroid Comparison'));
+    // ── Layer 9: Scandroid — Hartman's own, fully independent second opinion ──
+    // Its own dictionary, its own syllabifier, its own algorithms; reads only
+    // the raw line text.  Never touches or is touched by anything above.
+    if (result.scandroidNative) {
+        const sn = result.scandroidNative;
+        lines.push(H1('Scandroid (independent)'));
         lines.push('');
-        if (result.scandroidCorral) {
-            lines.push('  ' + H2('CW: ') + result.scandroidCorral.scansion);
+        const lengthTxt = sn.lineFeetSet ? sn.lineLengthName : `${sn.lineLengthName} (variable length)`;
+        lines.push('  ' + H2('Metron:   ') + `${sn.metronName} ${lengthTxt}`);
+        if (sn.verdict) {
+            const failTxt = sn.verdict.ok ? '' : chalk.red(' FAIL' + (sn.verdict.failReason ? ` (${sn.verdict.failReason})` : ''));
+            lines.push('  ' + H2('Verdict:  ') + `${sn.verdict.algorithm} — ${sn.verdict.scanString}` + failTxt);
+            lines.push('  ' + H2('Marks:    ') + sn.verdict.marksString + '   ' + chalk.dim(`${sn.verdict.substitutions} substitution(s)`));
         }
-        if (result.scandroidMaximise) {
-            lines.push('  ' + H2('MN: ') + result.scandroidMaximise.scansion);
+        else {
+            lines.push('  ' + H2('Verdict:  ') + chalk.red('FAIL (no scannable resolution)'));
         }
+        if (sn.corralTheWeird)
+            lines.push('  ' + H2('CW:       ') + sn.corralTheWeird.scanString + (sn.corralTheWeird.ok ? '' : chalk.red(' FAIL')));
+        if (sn.maximizeTheNormal)
+            lines.push('  ' + H2('MN:       ') + sn.maximizeTheNormal.scanString + (sn.maximizeTheNormal.ok ? '' : chalk.red(' FAIL')));
         lines.push('');
     }
+    // ── Layer 9b: Fabb–Halle bracketed grid (independent second opinion) ──
+    // When the caller supplies opts.fhSchema (the rule set F&H's OWN poem-level
+    // grid construction discovered — see buildFabbHalleGridsForPoem), the line
+    // is scanned under that; otherwise it falls back to stipulating the
+    // engine's final meter name.  Never fed back into the main scansion.
+    {
+        const fhSyls = linearSyls.map(ls => ({
+            text: ls.chunk,
+            lex: 0,
+            poly: ls.wordRef.syllables.length > 1,
+        }));
+        // Lexical stresses assigned positionally, walking words in surface order
+        // (mirrors how linearSyls itself was built).  Monosyllabic function
+        // words stay lex 0 — clitics carry no lexical stress in F&H's sense.
+        {
+            let k = 0;
+            for (const w of words) {
+                if (isPunctuation(w.lexicalClass))
+                    continue;
+                const cliticMono = w.syllables.length === 1 && !w.isContent;
+                for (const s of w.syllables) {
+                    if (k < fhSyls.length)
+                        fhSyls[k].lex = cliticMono ? 0 : (s.lexicalStress ?? s.stress ?? 0);
+                    k++;
+                }
+            }
+        }
+        let fh;
+        let discoveredNote = '';
+        if (opts?.fhSchema) {
+            const size = opts.fhSchema === 'loose' ? 0
+                : opts.fhSchema === 'iambic' || opts.fhSchema === 'trochaic' ? 2 : 3;
+            fh = buildFabbHalleGrid(fhSyls, opts.fhSchema, size > 0 ? Math.floor(fhSyls.length / size) : undefined);
+            const engineMeter = detail.meter || '';
+            const agrees = engineMeter.includes(opts.fhSchema)
+                || (opts.fhSchema === 'loose' && /accentual|loose|dolnik|free/i.test(engineMeter));
+            discoveredNote = agrees
+                ? ' · poem-discovered by grid construction, agreeing with the engine'
+                : ` · poem-discovered by grid construction (the engine read ${engineMeter || 'nothing'})`;
+        }
+        else {
+            fh = buildFabbHalleGrid(fhSyls, detail.meter || '', detail.footCount);
+        }
+        if (fh) {
+            lines.push(H1('Fabb–Halle Grid') + chalk.dim('  — bracketed-grid scansion (Meter in Poetry, 2008); * projects, ( groups rightward, ) leftward'));
+            lines.push('');
+            lines.push('  ' + chalk.dim(fh.ruleLabel + discoveredNote));
+            const maximaSet = new Set(fh.maxima);
+            const violSet = new Set(fh.violations);
+            const colW = fhSyls.map((s, i) => Math.max(s.text.length, ...fh.rows.map(r => (r[i] || '').length)) + 1);
+            const pad = (t, wd) => t + ' '.repeat(Math.max(0, wd - t.length));
+            lines.push('  ' + chalk.dim('Syl: ') + fhSyls.map((s, i) => {
+                const t = pad(s.text, colW[i]);
+                return violSet.has(i) ? chalk.red(t) : maximaSet.has(i) ? chalk.yellow(t) : t;
+            }).join(''));
+            fh.rows.forEach((row, g) => {
+                lines.push('  ' + chalk.dim(`G${g}:  `) + row.map((m, i) => pad(m, colW[i])).join(''));
+            });
+            const verdict = fh.looseFeet != null
+                ? `${fh.looseFeet} feet — in a loose meter the foot count IS the meter; maxima anchor the feet, unfooted syllables are free`
+                : fh.maxima.length === 0
+                    ? 'no maxima in this line — vacuously metrical'
+                    : fh.violations.length === 0
+                        ? `${fh.maxima.length} maxim${fh.maxima.length === 1 ? 'um' : 'a'}, all project to gridline 1 → metrical`
+                        : `${fh.violations.length} of ${fh.maxima.length} maxima fail to project → unmetrical under these rules`;
+            lines.push('  ' + (fh.metrical ? chalk.green(verdict) : chalk.red(verdict)));
+            lines.push('');
+        }
+    }
     // ── Layer 10: Reading projection (stress gradient over the input) ──
     // A reading-view-style colourisation of the verbatim input, so the finalised
     // analysis always shows "something that looks like the input".  Falls back to
@@ -657,7 +759,7 @@ function renderLineGlossary(words) {
 }
 /** Surface form reduced to bare lowercase letters (drops apostrophes/hyphens). */
 function normWordForm(s) {
-    return s.toLowerCase().replace(/[^a-z]/g, '');
+    return s.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^a-z]/g, '');
 }
 /** Colour each orthographic syllable of an original token by its relative stress. */
 function colourToken(tokenText, word) {
@@ -702,7 +804,7 @@ function colourToken(tokenText, word) {
  * the rest of the line.  No original character is ever dropped.
  */
 export function projectStressOntoLine(rawLine, words) {
-    const tokenRe = /[A-Za-z]+(?:['’\-][A-Za-z]+)*/g;
+    const tokenRe = /[A-Za-z\u00C0-\u024F]+(?:['’\-][A-Za-z\u00C0-\u024F]+)*/g; // accented Latin included (Milésien)
     let out = '';
     let cursor = 0;
     let wi = 0;

package/dist/fabbhalle.d.ts

@@ -0,0 +1,54 @@
+export interface FHSyllable {
+    text: string;
+    lex: number;
+    poly: boolean;
+}
+export interface FabbHalleResult {
+    ruleLabel: string;
+    rows: string[][];
+    maxima: number[];
+    violations: number[];
+    metrical: boolean;
+    complete: boolean;
+    looseFeet?: number;
+}
+/** How maxima are defined.  'flanked' is the English strict-meter condition
+ *  (F&H 2006 (16)): primary stress in a polysyllable, preceded AND followed
+ *  in the line by syllables without lexical stress — line-edge syllables
+ *  never qualify.  'polysyllabic' drops the flanking clause: any polysyllable
+ *  primary stress is a maximum.  That is the correct parameter for RUSSIAN
+ *  strict meters, where the empirical law (Taranovsky/Jakobson; F&H treat
+ *  Russian with the same parametric latitude their fn. 12 grants) is that a
+ *  polysyllabic word's stress may fall only on an ictus, with no adjacency
+ *  escape hatch — Russian classical verse simply does not license the
+ *  clash-adjacent inversions English does. */
+export type MaximaMode = 'flanked' | 'polysyllabic';
+export interface FabbHalleOptions {
+    maximaMode?: MaximaMode;
+}
+/**
+ * Build the bracketed grid for one line.  `meterName` selects the rule set —
+ * a single derivation VERIFIES a line against a stipulated rule set; meter
+ * DISCOVERY is a poem-level matter (see buildFabbHalleGridsForPoem below).
+ * `footCount`, when the caller supplies it, fixes the expected G0 count so
+ * that OVERLONG lines exercise
+ * F&H's optional NON-PROJECTION (their underlined syllables: synaloepha,
+ * "Heav'n"-type syncope, feminine endings — §1.1 example (2)).  Only
+ * lexically stressless syllables may fail to project; the choice minimizes
+ * maximum-condition violations, ties resolving to the EARLIEST position
+ * (King James VI's observation that projection is likelier near the line's
+ * end).  ACCENTUAL / dol'nik verdicts route to the LOOSE-meter rules
+ * instead.  Returns null when the line's meter has no F&H rule set.
+ */
+export declare function buildFabbHalleGrid(syls: FHSyllable[], meterName: string, footCount?: number, options?: FabbHalleOptions): FabbHalleResult | null;
+export interface FabbHallePoemResult {
+    schema: string;
+    grids: (FabbHalleResult | null)[];
+    cost: number;
+    runnerUp?: {
+        schema: string;
+        cost: number;
+    };
+}
+export declare function buildFabbHalleGridsForPoem(lines: FHSyllable[][], options?: FabbHalleOptions): FabbHallePoemResult | null;
+//# sourceMappingURL=fabbhalle.d.ts.map

package/dist/fabbhalle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fabbhalle.d.ts","sourceRoot":"","sources":["../src/fabbhalle.ts"],"names":[],"mappings":"AAkCA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA0FD;;;;;;;;;8CAS8C;AAC9C,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,cAAc,CAAC;AAEpD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AA6FD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,UAAU,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GACpF,eAAe,GAAG,IAAI,CAkGxB;AAoBD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,CAAC,eAAe,GAAG,IAAI,CAAC,EAAE,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7C;AAiBD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAChD,mBAAmB,GAAG,IAAI,CAiC5B"}

package/dist/fabbhalle.js

@@ -0,0 +1,404 @@
+// fabbhalle.ts — Fabb & Halle (2008, *Meter in Poetry*) Bracketed-Grid
+// scansion: an INDEPENDENT second-opinion module beside Scandroid.
+//
+// F&H hold that the fundamental principle of metrical verse is COUNTING, not
+// rhythm: each syllable projects an asterisk on gridline 0; iterative rules
+// insert parentheses (a left paren groups rightward, a right paren leftward),
+// each group projects its HEAD (edgemost asterisk) to the next gridline, and
+// a well-formed grid terminates with EXACTLY ONE asterisk on the bottom
+// gridline (their condition (11)).  Rhythm falls out as a condition stated
+// over the grid — for English strict meters, condition (7)/(8):
+//
+//   A MAXIMUM — a syllable carrying primary stress in a polysyllabic word,
+//   preceded AND followed in the same line by syllables without lexical
+//   stress — must project to gridline 1.
+//
+// Monosyllables are unregulated (their placement is a *tendency*, which Fabb
+// 2004 argues is implied form, explained pragmatically — not constitutive
+// form, not part of the generative rules).  This is deliberately a far more
+// LINEAR and textocentric method than the Calliope pipeline (McAleese's
+// critique); it is offered as an extra signal, never feeding the main
+// scansion.
+//
+// Rule sets follow the worked examples: iambic pentameter (F&H 2006 (5)-(14):
+// G0 R→L binary heads-right; G1 R→L ternary, final metron binary; all higher
+// gridlines likewise R→L — rules (11) and (13) both begin "at the right
+// edge", and the head is always the edgemost asterisk in the direction of
+// iteration), trochaic tetrameter (Keats 'Fancy': all gridlines L→R binary,
+// heads left), anapestic tetrameter (Byron 'Sennacherib': G0 R→L ternary
+// heads-right, initial group may be incomplete).  Amphibrachic lines fall
+// out of the ANAPESTIC rules for free: R→L ternary grouping of an
+// 11-syllable amphibrachic tetrameter yields groups |2|3|3|3| whose right
+// heads sit at positions 2·5·8·11 — exactly the amphibrach's medial beats
+// (F&H have no medial-headed groups; none are needed).
+/** Group the asterisks at `cols` per `spec`; return groups in left-to-right
+ *  order, each an array of member columns.  The group at the far end of the
+ *  iteration may be incomplete (F&H allow non-maximal edge groups). */
+function group(cols, spec) {
+    const groups = [];
+    if (spec.dir === 'RL') {
+        for (let end = cols.length; end > 0; end -= spec.size) {
+            const start = Math.max(0, end - spec.size);
+            groups.unshift(cols.slice(start, end));
+        }
+    }
+    else {
+        for (let start = 0; start < cols.length; start += spec.size) {
+            groups.push(cols.slice(start, Math.min(cols.length, start + spec.size)));
+        }
+    }
+    return groups;
+}
+/** Head column of a group: rightmost for RL ')' groups, leftmost for LR '(' . */
+function headOf(g, spec) {
+    return spec.dir === 'RL' ? g[g.length - 1] : g[0];
+}
+/** Pick the grouping rule for a HIGHER gridline holding `n` asterisks,
+ *  following the paper's worked examples where they exist.  Pentameter (F&H
+ *  2006 rule (11)/(12)): G1 ternary R→L with the final (last-constructed,
+ *  leftmost) metron binary.  Trimeter ("Up-Hill" (33), "Yes, to the very
+ *  end"): G1 BINARY — `*) * *)`, two metra {1},{2,3} — NOT one ternary
+ *  group.  Hexameter (fn. 9): two full ternary metra.  Tetrameter: binary.
+ *  Direction: every gridline of a meter iterates the same way as its G0 —
+ *  rules (11) and (13) both begin "at the right edge" for iambic, and the
+ *  head is the edgemost asterisk in the direction of iteration ("the
+ *  rightmost asterisk in each group projects"), so heads-right throughout
+ *  R→L meters and, mirror-image, heads-left throughout L→R meters. */
+function higherSpec(n, g0dir) {
+    const dir = g0dir;
+    if (n <= 4)
+        return { dir, size: 2 }; // incl. n=3 → {1},{2,3} per (33)
+    if (n % 3 === 0)
+        return { dir, size: 3 };
+    if (n % 2 === 0)
+        return { dir, size: 2 };
+    return { dir, size: 3 }; // odd ≥ 5 → ternary w/ final binary
+}
+/** G0 rule set from the main engine's meter family name.  Returns null for
+ *  meters outside F&H's English inventory (accentual, free…). */
+function g0Spec(meterName) {
+    const m = meterName.toLowerCase();
+    if (m.includes('iamb'))
+        return { spec: { dir: 'RL', size: 2 }, label: 'iambic: G0 Right-to-Left binary, heads right' };
+    if (m.includes('troch'))
+        return { spec: { dir: 'LR', size: 2 }, label: 'trochaic: G0 Left-to-Right binary, heads left' };
+    if (m.includes('amph'))
+        return { spec: { dir: 'LR', size: 3 }, label: 'amphibrachic: G0 Left-to-Right ternary, heads left (initial ∆ unprojected)', dropFirst: true };
+    if (m.includes('anap'))
+        return { spec: { dir: 'RL', size: 3 }, label: 'anapestic: G0 Right-to-Left ternary, heads right' };
+    if (m.includes('dact'))
+        return { spec: { dir: 'LR', size: 3 }, label: 'dactylic: G0 Left-to-Right ternary, heads left' };
+    return null;
+}
+/** Construct rows + G0 head set for a given projection (the columns that
+ *  project to gridline 0), leaving unprojected columns blank on every row. */
+function construct(syls, projected, g0) {
+    const rows = [];
+    let cols = projected.slice();
+    let g1cols = new Set();
+    let spec = g0.spec;
+    for (let g = 0; g < 4 && cols.length > 1; g++) {
+        if (g > 0)
+            spec = higherSpec(cols.length, g0.spec.dir);
+        const groups = group(cols, spec);
+        const row = syls.map(() => '');
+        for (const c of cols)
+            row[c] = '*';
+        for (const grp of groups) {
+            if (spec.dir === 'RL')
+                row[grp[grp.length - 1]] = '*)';
+            else
+                row[grp[0]] = '(*';
+        }
+        rows.push(row);
+        const heads = groups.map(grp => headOf(grp, spec));
+        if (g === 0)
+            g1cols = new Set(heads);
+        cols = heads;
+    }
+    const bottom = syls.map(() => '');
+    if (cols.length === 1)
+        bottom[cols[0]] = '*';
+    rows.push(bottom);
+    return { rows, g1cols, complete: cols.length === 1 };
+}
+/** Maxima per condition (8)/(16), or the flanking-free Russian variant. */
+function findMaxima(syls, mode) {
+    const maxima = [];
+    if (mode === 'polysyllabic') {
+        for (let i = 0; i < syls.length; i++) {
+            if (syls[i].poly && syls[i].lex >= 2)
+                maxima.push(i);
+        }
+        return maxima;
+    }
+    for (let i = 1; i < syls.length - 1; i++) {
+        if (!syls[i].poly || syls[i].lex < 2)
+            continue;
+        if (syls[i - 1].lex === 0 && syls[i + 1].lex === 0)
+            maxima.push(i);
+    }
+    return maxima;
+}
+/**
+ * LOOSE iambic meter (F&H 2006 §3, "Spring Quiet"): in loose meters maxima
+ * DETERMINE grid construction rather than being checked against it.
+ *   (21) maximum = any syllable carrying primary stress in a polysyllable
+ *        (no flanking condition);
+ *   (22) insert a right parenthesis after each maximum's asterisk, FIRST;
+ *   (23) then iterate R→L: skip one asterisk, insert a LEFT parenthesis to
+ *        the left of the next — but an already-parenthesized asterisk
+ *        refuses the insertion and the procedure reverts to the skip step
+ *        (the (27) walkthrough: "Arching high over" → *) * (* *) *).
+ * Feet are asterisk runs preceded by "(" or followed by ")" (definition (6),
+ * Idsardi's one-boundary feet); syllables between feet stay UNFOOTED (the
+ * "-ching" of "Arching").  Line length = FEET, so 4–7-syllable lines all
+ * count as dimeter — the meter of folk verse, ballads, dol'nik.  Heads
+ * project right.  Condition (17) does not apply: metricality is the foot
+ * count itself.
+ */
+function buildLooseGrid(syls) {
+    const n = syls.length;
+    const rightP = new Array(n).fill(false);
+    const leftP = new Array(n).fill(false);
+    const maxima = [];
+    for (let i = 0; i < n; i++) {
+        if (syls[i].poly && syls[i].lex >= 2) {
+            maxima.push(i);
+            rightP[i] = true;
+        }
+    }
+    // Iterative footing (23): skip-first, R→L.
+    let p = n - 1;
+    let state = 'skip';
+    while (p >= 0) {
+        if (state === 'skip') {
+            p--;
+            state = 'insert';
+            continue;
+        }
+        if (rightP[p] || leftP[p]) {
+            state = 'skip';
+            continue;
+        } // insertion refused
+        leftP[p] = true;
+        p--;
+        state = 'skip';
+    }
+    // Feet: "(…" runs and bare "…)" singletons; unfooted syllables in neither.
+    const feet = [];
+    let open = null;
+    for (let i = 0; i < n; i++) {
+        if (leftP[i]) {
+            if (open)
+                feet.push(open);
+            open = [i];
+        }
+        else if (open) {
+            open.push(i);
+        }
+        if (rightP[i]) {
+            if (open) {
+                feet.push(open);
+                open = null;
+            }
+            else
+                feet.push([i]);
+        }
+    }
+    if (open)
+        feet.push(open);
+    // Display: G0 marks + G1 heads (rightmost per foot) — the loose grid stops
+    // at the foot count, which IS the meter (F&H display no deeper gridlines
+    // for Spring Quiet).
+    const rows = [];
+    rows.push(syls.map((_, i) => {
+        if (leftP[i] && rightP[i])
+            return '(*)';
+        if (leftP[i])
+            return '(*';
+        if (rightP[i])
+            return '*)';
+        return '*';
+    }));
+    const g1 = syls.map(() => '');
+    for (const f of feet)
+        g1[f[f.length - 1]] = '*';
+    rows.push(g1);
+    return {
+        ruleLabel: `loose iambic (maxima-anchored, F&H 2006 §3): pre-paren maxima, then Right-to-Left skip-first left parens — ${feet.length} feet`,
+        rows,
+        maxima,
+        violations: [],
+        metrical: true,
+        complete: true,
+        looseFeet: feet.length,
+    };
+}
+/**
+ * Build the bracketed grid for one line.  `meterName` selects the rule set —
+ * a single derivation VERIFIES a line against a stipulated rule set; meter
+ * DISCOVERY is a poem-level matter (see buildFabbHalleGridsForPoem below).
+ * `footCount`, when the caller supplies it, fixes the expected G0 count so
+ * that OVERLONG lines exercise
+ * F&H's optional NON-PROJECTION (their underlined syllables: synaloepha,
+ * "Heav'n"-type syncope, feminine endings — §1.1 example (2)).  Only
+ * lexically stressless syllables may fail to project; the choice minimizes
+ * maximum-condition violations, ties resolving to the EARLIEST position
+ * (King James VI's observation that projection is likelier near the line's
+ * end).  ACCENTUAL / dol'nik verdicts route to the LOOSE-meter rules
+ * instead.  Returns null when the line's meter has no F&H rule set.
+ */
+export function buildFabbHalleGrid(syls, meterName, footCount, options) {
+    if (syls.length < 2)
+        return null;
+    if (meterName === 'auto') {
+        // Fallback only — F&H's parse is relative to a STIPULATED meter, so
+        // callers that know the line's meter must pass it.  Kept for lines whose
+        // verdict names no meter at all.
+        const schemas = ['iambic', 'trochaic', 'dactylic', 'amphibrachic', 'anapestic', 'loose'];
+        let bestRes = null;
+        let bestScore = -Infinity;
+        for (const schema of schemas) {
+            const res = buildFabbHalleGrid(syls, schema, footCount, options);
+            if (!res)
+                continue;
+            // Score: heavily penalize violations; loose meter gets a constant penalty so strict meters win if perfect.
+            let score = 0;
+            if (schema === 'loose') {
+                score = -5; // Loose meter base penalty
+            }
+            else {
+                score -= res.violations.length * 10;
+                if (!res.metrical)
+                    score -= 100;
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                bestRes = res;
+            }
+        }
+        return bestRes;
+    }
+    if (/accentual|dolnik|dol'nik|loose/i.test(meterName))
+        return buildLooseGrid(syls);
+    const g0 = g0Spec(meterName);
+    if (!g0)
+        return null;
+    const maxima = findMaxima(syls, options?.maximaMode ?? 'flanked');
+    const all = syls.map((_, i) => i);
+    if (g0.dropFirst && all.length > 0) {
+        all.shift();
+    }
+    // Candidate projections:
+    // F&H allow dropping syllables that don't project to G0 (e.g. feminine endings, synaloepha).
+    // If footCount is provided, we use it to calculate exactly how many to drop.
+    // Otherwise, we guess by trying to drop up to 2 final stressless syllables.
+    let candidates = [all];
+    const expected = footCount && footCount > 0 ? footCount * g0.spec.size : 0;
+    if (expected > 0) {
+        const extra = all.length - expected;
+        if (extra === 1 || extra === 2) {
+            const droppable = all.filter(i => syls[i].lex === 0);
+            const sets = [];
+            if (extra === 1) {
+                for (const d of droppable)
+                    sets.push(all.filter(i => i !== d));
+            }
+            else {
+                for (let a = 0; a < droppable.length; a++) {
+                    for (let b = a + 1; b < droppable.length; b++) {
+                        sets.push(all.filter(i => i !== droppable[a] && i !== droppable[b]));
+                    }
+                }
+            }
+            // The FULL projection stays a candidate alongside the drop sets: a
+            // "long" line may equally be a CATALECTIC line of the next foot count
+            // (amphibrachic 11 = 4 feet with a short final group, not 3 feet + 2
+            // extrametricals), and F&H's incomplete-final-group allowance handles
+            // it without non-projection.  Violation-minimisation picks per line.
+            candidates = [all, ...sets];
+        }
+    }
+    else {
+        // No expected count: try dropping 1 or 2 final stressless syllables
+        // (feminine/dactylic endings) alongside the full projection.
+        if (all.length > 0 && syls[all[all.length - 1]].lex === 0) {
+            const c2 = all.slice(0, -1);
+            candidates.push(c2);
+            if (c2.length > 0 && syls[c2[c2.length - 1]].lex === 0) {
+                candidates.push(all.slice(0, -2));
+            }
+        }
+    }
+    let best = null;
+    let bestViol = Infinity;
+    for (const proj of candidates) {
+        const c = construct(syls, proj, g0);
+        const viol = maxima.filter(i => proj.includes(i) && !c.g1cols.has(i)).length
+            + (c.complete ? 0 : 10);
+        if (viol < bestViol) {
+            bestViol = viol;
+            best = c;
+        }
+        if (bestViol === 0)
+            break; // earliest zero-violation wins
+    }
+    if (!best)
+        return null;
+    const violations = maxima.filter(i => !best.g1cols.has(i));
+    return {
+        ruleLabel: g0.label,
+        rows: best.rows,
+        maxima,
+        violations,
+        metrical: violations.length === 0 && best.complete,
+        complete: best.complete,
+    };
+}
+const DISCOVERY_SCHEMAS = ['iambic', 'trochaic', 'anapestic', 'amphibrachic', 'dactylic'];
+// The condition on maxima is INVIOLABLE in a strict meter ("MAXIMA must
+// project to gridline 1") — so a violation costs far more than the loose
+// reading's flat per-line rate: a poem whose lines keep violating under
+// every strict setting (a dol'nik) tips to loose, while sporadic violations
+// (tagger noise on a homograph, a genuinely transgressive line) don't flip
+// an otherwise-clean strict poem.
+const VIOLATION_COST = 2.0;
+const INCOMPLETE_COST = 6.0;
+const LOOSE_COST_PER_LINE = 0.9;
+function schemaFootSize(schema) {
+    return schema === 'iambic' || schema === 'trochaic' ? 2 : 3;
+}
+export function buildFabbHalleGridsForPoem(lines, options) {
+    const usable = lines.filter(l => l.length >= 2);
+    if (usable.length === 0)
+        return null;
+    const ranked = [];
+    for (const schema of DISCOVERY_SCHEMAS) {
+        const size = schemaFootSize(schema);
+        let cost = 0;
+        for (const syls of usable) {
+            const fh = buildFabbHalleGrid(syls, schema, Math.floor(syls.length / size), options);
+            if (!fh) {
+                cost += 8;
+                continue;
+            }
+            cost += fh.violations.length * VIOLATION_COST + (fh.complete ? 0 : INCOMPLETE_COST);
+        }
+        ranked.push({ schema, cost });
+    }
+    ranked.push({ schema: 'loose', cost: usable.length * LOOSE_COST_PER_LINE });
+    // Stable sort: ties resolve to the DISCOVERY_SCHEMAS order (a frequency
+    // prior over the tradition's meters — iambic first), loose last.
+    ranked.sort((a, b) => a.cost - b.cost);
+    const winner = ranked[0];
+    const size = winner.schema === 'loose' ? 0 : schemaFootSize(winner.schema);
+    const grids = lines.map(syls => syls.length < 2 ? null :
+        buildFabbHalleGrid(syls, winner.schema, size > 0 ? Math.floor(syls.length / size) : undefined, options));
+    return {
+        schema: winner.schema,
+        grids,
+        cost: winner.cost,
+        runnerUp: ranked[1] ? { schema: ranked[1].schema, cost: ranked[1].cost } : undefined,
+    };
+}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AA0B5C,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAOV,UAAU,EAMX,MAAM,YAAY,CAAC;AAkLpB,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,UAAO,EAAE,MAAM,GAAE,aAA4B,GAAG,UAAU,EAAE,EAAE,CA2CtH;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,UAAO,EAAE,MAAM,GAAE,aAA4B,GAAG,UAAU,EAAE,CAGjH;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,aAA4B,GAAG,aAAa,EAAE,CA0B1G;AAwCD,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB,MAAM,WAAW,OAAO;IAAG,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;CAAE;AAC7E,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,wBAAgB,UAAU,IAAI,OAAO,CAAoD;AAMzF;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,QAAQ,CAoCrE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAsB5C,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAKV,UAAU,EAMX,MAAM,YAAY,CAAC;AAyLpB,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,UAAO,EAAE,MAAM,GAAE,aAA4B,GAAG,UAAU,EAAE,EAAE,CAuDtH;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,UAAO,EAAE,MAAM,GAAE,aAA4B,GAAG,UAAU,EAAE,CAGjH;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,aAA4B,GAAG,aAAa,EAAE,CAkC1G;AAqDD,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB,MAAM,WAAW,OAAO;IAAG,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;CAAE;AAC7E,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,wBAAgB,UAAU,IAAI,OAAO,CAAoD;AAMzF;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,QAAQ,CAoCrE"}