@heroiclands/package-build 22.16.0 → 22.17.1

package/engine/reckoning-markers.mjs

@@ -1,70 +1,64 @@
-/*
- * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
- * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
- *
- * This work is licensed under the GNU General Public License v3.0 (GPLv3).
- * You may copy, modify, and distribute it under the terms of that license.
- *
- * SPDX-License-Identifier: GPL-3.0-or-later
- */
+/* SPDX-License-Identifier: GPL-3.0-or-later */
 
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
-import { canonicalDayOffset, daysInMonth } from "./calendars.mjs";
-import { DATEFROM_PATTERN, parseNoteDate } from "./note-dates.mjs";
-import { eraNames } from "./calendar-human.mjs";
-import { addressSuffixes, renderAddress } from "./address-render.mjs";
+import {
+    canonicalDateFromOffset,
+    canonicalDayOffset,
+    canonicalYear,
+    parseCanonicalDate,
+} from "./calendars.mjs";
+import { renderAddress } from "./address-render.mjs";
 
-/**
- * Resolve every declared reckoning marker against its calendar and era start.
- * The marker names one era, while the calendar supplies the month layout.
- *
- * @param {{notes?: readonly object[]}} index - The corpus link index.
- * @param {number} daysPerYear - The world's year length.
- * @returns {{eras: Map<string, object>, markers: Map<string, object>, findings: object[]}} Resolved eras, markers, and errors.
- */
+/** Resolve calendar eras on the canonical day axis. */
 export function resolveReckoningMarkers(index, daysPerYear) {
-    const declared = new Map();
-    const qualifiers = new Map();
-    const markerKeys = new Map();
     const eras = new Map();
     const markers = new Map();
     const findings = [];
-    const failed = new Set();
-    const visiting = [];
+    const qualifiers = new Map();
+    const markerOwners = new Map();
+    const calendarRows = [];
 
-    const location = (row, key) => ({
-        ...(row.note.file === undefined ? {} : { file: row.note.file }),
-        ...(row.note.raw === undefined ?
+    const location = (note, position, key) => ({
+        ...(note.file === undefined ? {} : { file: note.file }),
+        ...(note.raw === undefined ?
             {}
-        :   positionOfFrontmatterPath(row.note.raw, ["data", "eras", row.position, key])),
+        :   positionOfFrontmatterPath(note.raw, ["data", "eras", position, key])),
     });
-    const finding = (row, key, message) =>
-        findings.push({
-            ...location(row, key),
-            severity: "error",
-            message,
-        });
-    const alias = (qualifier, key) => {
-        if (qualifiers.has(qualifier) && qualifiers.get(qualifier) !== key)
-            qualifiers.set(qualifier, null);
-        else qualifiers.set(qualifier, key);
-    };
+    const error = (note, position, key, message) =>
+        findings.push({ ...location(note, position, key), severity: "error", message });
 
     for (const note of index?.notes ?? []) {
         const fm = note?.fm ?? note?.frontmatter ?? note;
         if (fm?.type !== "lore" || fm?.subType !== "calendar") continue;
-        const rows = fm.data?.eras;
+        const data = fm.data ?? {};
+        const rows = data.eras;
         if (!Array.isArray(rows)) continue;
-        rows.forEach((era, position) => {
-            if (
-                !era ||
-                typeof era.shortcode !== "string" ||
-                !era.shortcode ||
-                typeof fm.shortcode !== "string" ||
-                !fm.shortcode
-            )
-                return;
-            const pkg = fm.package ?? note.package ?? index?.contentPackage;
+        if (!Number.isSafeInteger(daysPerYear) || daysPerYear < 1) continue;
+        const epochText = String(data.epoch ?? "");
+        const epoch = parseCanonicalDate(epochText, daysPerYear);
+        if (!epoch || epoch.year === 0 || epoch.seconds !== undefined) {
+            findings.push({
+                ...(note.file === undefined ? {} : { file: note.file }),
+                ...(note.raw === undefined ?
+                    {}
+                :   positionOfFrontmatterPath(note.raw, ["data", "epoch"])),
+                severity: "error",
+                message:
+                    "data.epoch must be a canonical <year>.<day> anchoring calendar year 1, day 1",
+            });
+            continue;
+        }
+        const epochOffset = canonicalDayOffset(
+            canonicalYear(epoch.year),
+            epoch.day,
+            1,
+            daysPerYear,
+        );
+        const pkg = fm.package ?? note.package ?? index?.contentPackage;
+        const declared = [];
+        for (const [position, era] of rows.entries()) {
+            if (!era || typeof era.shortcode !== "string" || !era.shortcode || !fm.shortcode)
+                continue;
             const short = `${fm.shortcode}.${era.shortcode}`;
             const key =
                 pkg ?
@@ -73,235 +67,139 @@ export function resolveReckoningMarkers(index, daysPerYear) {
             const row = {
                 key,
                 era: short,
-                calendar: fm.data,
-                marker: era.marker,
+                calendar: data,
                 calendarShortcode: fm.shortcode,
+                note,
+                position,
+                start: era.start,
                 name: era.name,
                 abbreviation: era.abbreviation,
+                marker: era.marker,
                 label: era.label,
-                start: era.start,
-                end: era.end,
-                note,
-                position,
             };
-            if (declared.has(key)) {
-                return;
+            declared.push(row);
+            const aliases = [short, `lore-${short}`, `note-lore-${short}`];
+            for (const alias of aliases) {
+                if (qualifiers.has(alias) && qualifiers.get(alias) !== key)
+                    qualifiers.set(alias, null);
+                else qualifiers.set(alias, key);
             }
-            declared.set(key, row);
-            alias(short, key);
-            if (pkg) {
-                alias(
-                    renderAddress({ package: pkg, system: "note", type: "lore", shortcode: short }),
-                    key,
-                );
-                alias(`note-lore-${short}`, key);
-                alias(`lore-${short}`, key);
+            if (era.marker !== undefined) {
+                if (typeof era.marker !== "string" || !/^[A-Z][A-Z0-9]*$/.test(era.marker))
+                    error(
+                        note,
+                        position,
+                        "marker",
+                        "an era marker needs uppercase letters and digits",
+                    );
+                else if (markerOwners.has(era.marker))
+                    error(
+                        note,
+                        position,
+                        "marker",
+                        `reckoning marker ${era.marker} is declared more than once`,
+                    );
+                else markerOwners.set(era.marker, key);
             }
-            if (era.marker === undefined) return;
-            if (typeof era.marker !== "string" || !/^[A-Z][A-Z0-9]*$/.test(era.marker)) {
-                finding(
-                    row,
-                    "marker",
-                    "an era marker is uppercase letters and digits, starting with a letter",
+            if (era.end !== undefined)
+                error(
+                    note,
+                    position,
+                    "end",
+                    "an era ends when the next calendar year era begins; omit end",
                 );
-                return;
-            }
-            if (markerKeys.has(era.marker)) {
-                finding(row, "marker", `reckoning marker ${era.marker} is declared more than once`);
-                return;
-            }
-            markerKeys.set(era.marker, key);
-        });
+        }
+        calendarRows.push({ note, declared, epochOffset });
     }
 
-    for (const [qualifier, key] of qualifiers)
-        if (key === null) eras.set(qualifier, { ambiguous: true });
-
-    function resolve(key) {
-        if (key === null || !declared.has(key) || failed.has(key)) return null;
-        const row = declared.get(key);
-        if (eras.has(key)) return eras.get(key);
-        if (visiting.includes(key)) {
-            const members = [...visiting.slice(visiting.indexOf(key)), key].map(
-                (member) => declared.get(member).era,
+    for (const { note, declared, epochOffset } of calendarRows) {
+        const nullRows = declared.filter((row) => row.start === null);
+        const firstRows = declared.filter((row) => row.start === 1);
+        if (nullRows.length !== 1)
+            error(
+                note,
+                nullRows[0]?.position ?? 0,
+                "start",
+                "a calendar needs exactly one start: null era before year 1",
             );
-            finding(row, "start", `calendar era cycle includes ${members.join(" → ")}`);
-            for (const member of visiting.slice(visiting.indexOf(key))) failed.add(member);
-            return null;
-        }
-        visiting.push(key);
-        if (row.start === undefined || row.start === null) {
-            finding(row, "start", `calendar era ${row.era} needs a start`);
-            failed.add(key);
-        }
-        const source = typeof row.start === "string" ? row.start.trim() : "";
-        const marker = /^([A-Z][A-Z0-9]*)\(/.exec(source)?.[1];
-        const qualifier = /\s+([^\s]+\.[^\s]+)$/.exec(source)?.[1];
-        const conversion = DATEFROM_PATTERN.exec(source);
-        const convertedRef = conversion?.[1];
-        const convertedDate = conversion?.[2];
-        const convertedRows =
-            convertedRef ?
-                [...declared.values()].filter((candidate) => {
-                    const fm = candidate.note.fm ?? candidate.note.frontmatter ?? candidate.note;
-                    const pkg = fm.package ?? candidate.note.package ?? index?.contentPackage;
-                    if (!pkg) return convertedRef === candidate.calendarShortcode;
-                    return addressSuffixes({
-                        package: pkg,
-                        system: "note",
-                        type: "lore",
-                        shortcode: candidate.calendarShortcode,
-                    }).includes(convertedRef);
-                })
-            :   [];
-        const convertedTargets = convertedRows.filter((candidate) =>
-            eraNames(candidate).some((name) =>
-                convertedDate?.toLowerCase().endsWith(` ${name.toLowerCase()}`),
-            ),
-        );
-        if (convertedTargets.length === 0 && convertedRows.length === 1)
-            convertedTargets.push(convertedRows[0]);
-        const dependency =
-            marker ? markerKeys.get(marker)
-            : qualifier ? qualifiers.get(qualifier)
-            : convertedTargets.length === 1 ? convertedTargets[0].key
-            : null;
-        if (dependency && !failed.has(key)) resolve(dependency);
-        if (!failed.has(key)) {
-            const parsed = parseNoteDate(row.start, {
-                markers,
-                eras,
-                daysPerYear,
-                field: "data.eras.start",
-                allowUnknown: false,
-                ...location(row, "start"),
-                raw: row.note.raw,
-                keyPath: ["data", "eras", row.position, "start"],
-            });
-            findings.push(...parsed.findings);
-            if (
-                Number.isSafeInteger(parsed.date?.canonicalYear) &&
-                parsed.findings.every((item) => item.severity !== "error")
-            ) {
-                const entry = {
-                    era: row.era,
-                    qualifier: row.key,
-                    marker: row.marker,
-                    firstEra: row.position === 0,
-                    calendar: row.calendar,
-                    calendarShortcode: row.calendarShortcode,
-                    name: row.name,
-                    abbreviation: row.abbreviation,
-                    label: row.label,
-                    epochYear: parsed.date.canonicalYear,
-                    epochDay: parsed.date.canonicalDay ?? 1,
-                };
-                if (Number.isSafeInteger(daysPerYear) && daysPerYear > 0)
-                    entry.startOffset = canonicalDayOffset(
-                        entry.epochYear,
-                        entry.epochDay,
-                        1,
-                        daysPerYear,
-                    );
-                eras.set(key, entry);
-                for (const [name, owner] of qualifiers) if (owner === key) eras.set(name, entry);
-                if (row.marker && markerKeys.get(row.marker) === key)
-                    markers.set(row.marker, entry);
-            } else failed.add(key);
-        }
-        visiting.pop();
-        return eras.get(key) ?? null;
-    }
-    for (const key of declared.keys()) resolve(key);
-    for (const row of declared.values()) {
-        const entry = eras.get(row.key);
-        if (!entry || row.end === undefined || row.end === null) continue;
-        const parsed = parseNoteDate(row.end, {
-            markers,
-            eras,
-            daysPerYear,
-            field: "data.eras.end",
-            allowUnknown: false,
-            file: row.note.file,
-            raw: row.note.raw,
-            keyPath: ["data", "eras", row.position, "end"],
-        });
-        findings.push(...parsed.findings);
-        if (!Number.isSafeInteger(parsed.date?.canonicalYear)) continue;
-        if (!Number.isSafeInteger(daysPerYear) || daysPerYear < 1) {
-            finding(
-                row,
-                "end",
-                `calendar era ${row.era} needs the world's year length to bound its end`,
+        if (firstRows.length !== 1)
+            error(
+                note,
+                firstRows[0]?.position ?? 0,
+                "start",
+                "a calendar needs exactly one era with start: 1",
             );
-            continue;
-        }
-        const firstEndDay = canonicalDayOffset(
-            parsed.date.canonicalYear,
-            parsed.date.canonicalDay ?? 1,
-            1,
-            daysPerYear,
-        );
-        const extraDays =
-            parsed.date.precision === "year" ? daysPerYear - 1
-            : parsed.date.precision === "month" ?
-                (daysInMonth(
-                    markers.get(parsed.date.marker)?.calendar ??
-                        eras.get(parsed.date.qualifier)?.calendar,
-                    parsed.date.month,
-                ) ?? 1) - 1
-            :   0;
-        const endOffset = firstEndDay + extraDays;
-        const startOffset = canonicalDayOffset(entry.epochYear, entry.epochDay, 1, daysPerYear);
-        if (endOffset < startOffset) {
-            finding(row, "end", `calendar era ${row.era} ends before its start`);
-            continue;
-        }
-        entry.endOffset = endOffset;
-    }
-    const calendars = new Map();
-    for (const row of declared.values()) {
-        const rows = calendars.get(row.note) ?? [];
-        rows.push(row);
-        calendars.set(row.note, rows);
-    }
-    for (const rows of calendars.values()) {
-        for (let position = 0; position < rows.length; position++) {
-            const row = rows[position];
-            const entry = eras.get(row.key);
-            if (!entry || !Number.isSafeInteger(entry.startOffset)) continue;
-            entry.firstEra = position === 0;
-            const next = rows[position + 1];
-            if (!next) continue;
-            const following = eras.get(next.key);
-            if (!following || !Number.isSafeInteger(following.startOffset)) continue;
-            if (following.startOffset <= entry.startOffset) {
-                finding(
-                    next,
+        const byStart = new Map();
+        for (const row of declared) {
+            if (row.start !== null && (!Number.isSafeInteger(row.start) || row.start < 1)) {
+                error(
+                    note,
+                    row.position,
                     "start",
-                    `calendar eras ${row.era} and ${next.era} must begin in increasing order`,
+                    "an era start is null or a positive integer calendar year",
                 );
                 continue;
             }
-            if (entry.endOffset !== undefined && entry.endOffset >= following.startOffset) {
-                finding(next, "start", `calendar eras ${row.era} and ${next.era} overlap`);
+            if (byStart.has(row.start)) {
+                error(note, row.position, "start", `calendar eras cannot share start ${row.start}`);
+                continue;
+            }
+            byStart.set(row.start, row);
+        }
+        const ordered = [...byStart.values()].sort((a, b) =>
+            a.start === null ? -1
+            : b.start === null ? 1
+            : a.start - b.start,
+        );
+        for (const [position, row] of ordered.entries()) {
+            const startOffset =
+                row.start === null ? epochOffset : epochOffset + (row.start - 1) * daysPerYear;
+            if (!Number.isSafeInteger(startOffset)) {
+                error(
+                    note,
+                    row.position,
+                    "start",
+                    "era start lies outside the supported day range",
+                );
                 continue;
             }
-            if (entry.endOffset === undefined) entry.endOffset = following.startOffset - 1;
+            const startDate = canonicalDateFromOffset(startOffset, 1, daysPerYear);
+            const next = ordered[position + 1];
+            const endOffset = next ? epochOffset + (next.start - 1) * daysPerYear - 1 : undefined;
+            const entry = {
+                era: row.era,
+                qualifier: row.key,
+                marker: row.marker,
+                firstEra: row.start === null,
+                beforeEra: row.start === null,
+                startYear: row.start,
+                calendar: row.calendar,
+                calendarShortcode: row.calendarShortcode,
+                name: row.name,
+                abbreviation: row.abbreviation,
+                label: row.label,
+                epochYear: startDate.year,
+                epochDay: startDate.day,
+                calendarEpochOffset: epochOffset,
+                startOffset,
+                ...(endOffset === undefined ? {} : { endOffset }),
+            };
+            eras.set(row.key, entry);
+            if (row.marker && markerOwners.get(row.marker) === row.key)
+                markers.set(row.marker, entry);
         }
     }
+    for (const [alias, key] of qualifiers) {
+        if (key === null) eras.set(alias, { ambiguous: true });
+        else if (eras.has(key)) eras.set(alias, eras.get(key));
+    }
     return { eras, markers, findings };
 }
 
-/** One resolved date context per corpus index, shared by its note checks. */
+/** One resolved date context per corpus index. */
 const contexts = new WeakMap();
 
-/**
- * Read the world's year length and its era markers from one corpus index.
- *
- * @param {{notes?: readonly object[]}|undefined} index - The corpus index.
- * @returns {{eras: Map<string, object>, markers: Map<string, object>, daysPerYear: number|undefined, findings: object[]}}
- */
+/** Read the world's year length and resolve every calendar era in one corpus. */
 export function reckoningContext(index) {
     if (!index || typeof index !== "object")
         return { eras: new Map(), markers: new Map(), daysPerYear: undefined, findings: [] };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.16.0",
+    "version": "22.17.1",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",
@@ -137,10 +137,12 @@
         "acorn": "^8.18.0",
         "archiver": "^8.0.0",
         "classic-level": "^3.0.0",
+        "dale-chall": "^2.0.1",
         "dotenv": "^18.0.0",
         "eslint": "^10.10.0",
         "eslint-plugin-yml": "^3.8.1",
         "fflate": "^0.8.3",
+        "flesch": "^2.0.1",
         "glob": "^13.0.6",
         "gray-matter": "^4.0.3",
         "handlebars": "^4.7.9",
@@ -153,6 +155,7 @@
         "pagefind": "^1.5.2",
         "prettier": "^3.9.6",
         "remark-frontmatter": "^5.0.0",
+        "remark-gfm": "^4.0.1",
         "remark-parse": "^11.0.0",
         "remark-retext": "^6.0.1",
         "retext-english": "^5.0.0",
@@ -162,6 +165,7 @@
         "sharp": "^0.35.4",
         "smol-toml": "^1.8.0",
         "ssh2-sftp-client": "^12.1.1",
+        "syllable": "^5.0.1",
         "typescript": "^6.0.3",
         "unidecode": "^1.1.0",
         "unified": "^11.0.5",

package/types/config.d.mts

@@ -94,7 +94,8 @@ export const DERIVED_MANIFEST_KEYS: Readonly<Record<string, string>>;
  *
  * @typedef {object} PackageBuildConfig
  * @property {string} rootDir        The repository root, from package-build.
- * @property {{age: number, threshold: number, minWords: number}} proseLint Optional prose analysis settings.
+ * @property {{age: number, threshold: number, minWords: number, rules: string}} proseLint Optional prose lint settings.
+ * @property {{minWords: number, bands: Record<string, {min?: number, max?: number}>}} proseScore Optional note score settings.
  * @property {string} packageKind    `systems` or `modules`.
  * @property {string} packageId      The Foundry package id.
  * @property {string} artifact       Derived: `system` or `module`.
@@ -198,12 +199,23 @@ export type PackageBuildConfig = {
      */
     rootDir: string;
     /**
-     * Optional prose analysis settings.
+     * Optional prose lint settings.
      */
     proseLint: {
         age: number;
         threshold: number;
         minWords: number;
+        rules: string;
+    };
+    /**
+     * Optional note score settings.
+     */
+    proseScore: {
+        minWords: number;
+        bands: Record<string, {
+            min?: number;
+            max?: number;
+        }>;
     };
     /**
      * `systems` or `modules`.

package/types/engine/calendar-format.d.mts

@@ -0,0 +1,33 @@
+/** Brackets and braces must close; `[[]` is a literal left bracket. */
+export function calendarFormatSyntaxError(pattern: any): string | null;
+/** Split a Calendaria pattern into tokens and literal text. */
+export function calendarFormatSegments(pattern: any): {
+    token: boolean;
+    value: any;
+}[];
+/** A standard format must identify one calendar day and be readable without context. */
+export function readableCalendarFormatError(pattern: any): string | null;
+/** Whether a selected pattern prints clock components. */
+export function calendarFormatHasClock(pattern: any): boolean;
+/** Keep the fields named by an authored date's precision. */
+export function calendarPatternSegmentsForPrecision(pattern: any, precision?: string, includeClock?: boolean): {
+    token: boolean;
+    value: any;
+}[];
+/** Choose an authored named format, with `std` as the preferred default. */
+export function selectCalendarFormat(calendar: any, name: any): {
+    name: any;
+    pattern: any;
+};
+/** Format calendar date components with Calendaria's documented tokens. */
+export function formatCalendarPattern(pattern: any, parts: any, precision?: string, includeClock?: boolean): string;
+/** Read the invertible date fields of one Calendaria pattern. */
+export function parseCalendarPattern(pattern: any, text: any, calendar: any): {
+    hour: number;
+};
+/** Convert a calendar month/day into its one-based day of year. */
+export function calendarOrdinal(calendar: any, month: any, day: any): number;
+/** Calendaria's bare date, time, week, season, and zone tokens. */
+export const CALENDAR_FORMAT_TOKENS: Readonly<Set<string>>;
+/** Calendaria's named fields inside brackets or braces. */
+export const CALENDAR_CUSTOM_TOKENS: Readonly<Set<string>>;

package/types/engine/calendar-notes.d.mts

@@ -18,7 +18,7 @@ export function worldInvariants(index?: object): {
     yearNote: object | null;
     moonNote: object | null;
 };
-/** Check each authored format slot and every unescaped letter run in it. */
+/** Check each named pattern and the standard pattern's readable fields. */
 export function checkCalendarDateFormats(note: any): {
     severity: any;
     message: any;
@@ -162,8 +162,7 @@ export const CALENDAR_SUBTYPE: "calendar";
 export const INVARIANT_SUBTYPES: readonly string[];
 /** Calendaria's display locations that a calendar note can format. */
 export const CALENDAR_DATE_FORMAT_KEYS: readonly string[];
-/** Bare date tokens Calendaria substitutes inside authored format strings. */
-export const CALENDAR_FORMAT_TOKENS: Readonly<Set<string>>;
+export { CALENDAR_FORMAT_TOKENS };
 /**
  * The `data:` keys a calendar note may write — the closed list, in authored
  * order.
@@ -185,3 +184,4 @@ export const CALENDAR_FIELDS: readonly object[];
  * @type {readonly object[]}
  */
 export const INVARIANT_FIELDS: readonly object[];
+import { CALENDAR_FORMAT_TOKENS } from "./calendar-format.mjs";

package/types/engine/date-conversion.d.mts

@@ -1,4 +1,4 @@
 /** Convert a day in an addressed calendar to its canonical spelling. */
 export function dateFromCalendar(reference: any, value: any, context: any): string;
 /** Convert a canonical day to the date in the covering era of a calendar. */
-export function dateToCalendar(reference: any, value: any, context: any): any;
+export function dateToCalendar(reference: any, value: any, context: any, formatName: any): any;

package/types/engine/note-dates.d.mts

@@ -60,7 +60,7 @@ export function eraCovering(date: any, eraRows: any, daysPerYear: any): any;
 /** Resolve a calendar or one of its eras from an Address or shortcode. */
 export function calendarEras(reference: any, context: any): any;
 /** Print a resolved date using the era active in one addressed calendar. */
-export function formatDateInCalendar(date: any, reference: any, context: any): {
+export function formatDateInCalendar(date: any, reference: any, context: any, formatName: any): {
     era: null;
     year: number;
     text: any;
@@ -76,7 +76,7 @@ export function formatDateInCalendar(date: any, reference: any, context: any): {
     prose: string | null;
 } | null;
 /** Print a resolved date in one era, retaining its authored precision. */
-export function formatNoteDate(date: any, era: any, daysPerYear: any): {
+export function formatNoteDate(date: any, era: any, daysPerYear: any, formatName: any): {
     era: null;
     year: number;
     text: any;

package/types/engine/readability-lint.d.mts

@@ -1,11 +1,7 @@
 /** Files in a content tree, excluding configured directory names. */
 export function proseFiles(root: any, skipDirectories?: any[]): any[];
 /** Source-aligned findings for one Markdown note. */
-export function analyzeProse(file: any, source: any, { age, threshold, minWords }?: {
-    age?: number | undefined;
-    threshold?: number | undefined;
-    minWords?: number | undefined;
-}): Promise<{
+export function analyzeProse(file: any, source: any, options?: {}): Promise<{
     file: any;
     line: any;
     column: any;
@@ -20,3 +16,13 @@ export function lintProse(root: any, options: any, skipDirectories?: any[]): Pro
     severity: string;
     message: string;
 }[]>;
+/** Score the complete prose paragraphs in one note. */
+export function scoreProse(file: any, source: any, { minWords, bands }?: {
+    minWords?: number | undefined;
+    bands?: {} | undefined;
+}): Promise<any>;
+/** Score a note or content tree and pool counts for its aggregate. */
+export function scoreProseTree(root: any, options: any, skipDirectories?: any[]): Promise<{
+    notes: any[];
+    summary: any;
+}>;