@heroiclands/package-build 23.8.0 → 23.10.0

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

@@ -43,7 +43,8 @@ export function isStubbableType(type: string | null | undefined, vocabulary?: Re
     stubbable?: boolean;
 }>>): boolean;
 /**
- * Whether a note is a stub: an empty body on a type an empty body suppresses.
+ * Whether a note is a stub: an empty body on a type an empty body suppresses,
+ * without an automatic dictionary or glossary supplied by its frontmatter.
  *
  * The one place the two halves are put together, so the index, the lint and the
  * guard cannot answer it differently.

package/types/engine/path-charset.d.mts

@@ -21,13 +21,28 @@ export function offendingPathCharacters(text: string): string[];
  * @param {string} opts.assetsBase - The package's asset directory, whose
  *   picture roots are walked.
  * @param {readonly string[]} [opts.skipDirectories] - Directory names to ignore.
+ * @param {ReturnType<import("./content-sources.mjs").captureContentSources>} [opts.inventory] - Captured physical paths in root walk order.
  * @returns {{findings: Array<{file: string, severity: "error", message: string}>,
  *   files: number}} The findings, and how many paths were checked.
  */
-export function lintPathCharset({ contentBase, assetsBase, skipDirectories }: {
+export function lintPathCharset({ contentBase, assetsBase, skipDirectories, inventory }: {
     contentBase: string;
     assetsBase: string;
     skipDirectories?: readonly string[] | undefined;
+    inventory?: {
+        sources: Map<string, {
+            raw: string;
+        }>;
+        indexSources: Map<string, {
+            raw: string;
+        }>;
+        paths: Array<{
+            root: string;
+            file: string;
+            name: string;
+            directory: boolean;
+        }>;
+    } | undefined;
 }): {
     findings: Array<{
         file: string;

package/types/engine/site-build.d.mts

@@ -109,11 +109,14 @@ export function writeHomepages(outRoot: string, pages: readonly object[], config
  * @param {object} options
  * @param {object} options.config - The resolved build configuration.
  * @param {object[]} options.records - Content-index records.
+ * @param {Map<string, object[]>} [options.sqlTables] - Prepared directives,
+ *   whose emitted anchors belong to the pages they expand in.
  * @returns {object} The gate results and, when they pass, the built index.
  */
-export function siteGates(pages: object[], findings: object, { config, records }: {
+export function siteGates(pages: object[], findings: object, { config, records, sqlTables }: {
     config: object;
     records: object[];
+    sqlTables?: Map<string, object[]> | undefined;
 }): object;
 /**
  * The gate result of a build that ran none of them.
@@ -250,8 +253,8 @@ export function renderSitePage(page: any, { index, foreign, universe, pass, deco
     secretErrors: {
         file: any;
         line: number;
-        column: any;
-        message: any;
+        column: number;
+        message: string;
     }[];
     captionErrors: {
         file: any;

package/types/engine/site-index.d.mts

@@ -13,9 +13,10 @@
  *   ordinary dead address.
  * @param {object[]} [options.records] - Content-index records.
  * @param {Map<string, object>} [options.foreignReferences] - Foreign reference targets.
+ * @param {import("./content-session.mjs").ContentSyntax} [options.syntax] - Exact-text scanner projections.
  * @returns {SiteIndex} The index, and what could not be addressed unambiguously.
  */
-export function buildSiteIndex(entries: readonly SiteEntry[], { foreignIndex, noIndexPackages, package: builderPackage, records, foreignReferences, }?: {
+export function buildSiteIndex(entries: readonly SiteEntry[], { foreignIndex, noIndexPackages, package: builderPackage, records, foreignReferences, syntax, }?: {
     foreignIndex?: Map<string, {
         package: string;
         type?: string;
@@ -23,6 +24,7 @@ export function buildSiteIndex(entries: readonly SiteEntry[], { foreignIndex, no
     noIndexPackages?: Set<string> | undefined;
     records?: object[] | undefined;
     foreignReferences?: Map<string, object> | undefined;
+    syntax?: import("./content-session.mjs").ContentSyntax | undefined;
 }): SiteIndex;
 /**
  * The address keys one page's figures are reachable by — the same two forms

package/types/engine/sql-tables.d.mts

@@ -191,20 +191,25 @@ export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<
  * @param {Map<string, Map<string, string>>} [opts.derived] - The derived
  *   lists, from an earlier call over the same records, which are not derived
  *   again.
+ * @param {object[]} [opts.all=records] - Complete records for lexical lineage
+ *   traversal through providers outside the surface's audience.
  * @returns {Promise<{sections: Map<string, string>, views: Set<string>,
- *   derived: Map<string, Map<string, string>>}>} Note file to its sections,
+ *   derived: Map<string, Map<string, string>>,
+ *   lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}>} Note file to its sections,
  *   joined in order; the files whose sections hold an event view's fence; and
  *   the derived lists alone.
  */
-export function generatedSectionsFor(db: object | undefined, records: object[], contentBase: string, { only, foreignIndex, config, derived: given }?: {
+export function generatedSectionsFor(db: object | undefined, records: object[], contentBase: string, { only, foreignIndex, config, derived: given, all }?: {
     only?: string | undefined;
     foreignIndex?: Map<string, object> | undefined;
     config?: object | undefined;
     derived?: Map<string, Map<string, string>> | undefined;
+    all?: object[] | undefined;
 }): Promise<{
     sections: Map<string, string>;
     views: Set<string>;
     derived: Map<string, Map<string, string>>;
+    lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>;
 }>;
 /**
  * Join each note's generated sections to its body among the sources a
@@ -243,12 +248,13 @@ export function joinGeneratedSections(generated: {
  * empty set carrying them.
  *
  * @param {Map<string, object[]>} prepared - From {@link prepareSqlTables}.
- * @param {{sections: Map<string, string>}} generated - From
+ * @param {{sections: Map<string, string>, lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}} generated - From
  *   {@link generatedSectionsFor}.
  * @returns {void}
  */
 export function attachGeneratedSections(prepared: Map<string, object[]>, generated: {
     sections: Map<string, string>;
+    lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>;
 }): void;
 /**
  * Each declared dependency's cached index, as {@link openNotesDatabase} attaches
@@ -297,11 +303,12 @@ export function cachedDependencies(config?: object): Promise<Array<{
  * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes the
  *   generated sections take in, where the caller holds them already; absent,
  *   they are read from the cache.
+ * @param {import("./content-session.mjs").ContentSyntax} [opts.syntax] - Exact-text scanner projections.
  * @returns {Promise<Map<string, object[]>|undefined>} Results by note path,
  *   carrying `inline` and `pageLists` beside them, or nothing when the tree
  *   holds no such directive and no note is given a generated section.
  */
-export function prepareTreeSqlTables(contentBase: string, { config, skipDirectories, records, parsed, database, audience, foreignIndex }?: {
+export function prepareTreeSqlTables(contentBase: string, { config, skipDirectories, records, parsed, database, audience, foreignIndex, syntax, }?: {
     config?: object | undefined;
     skipDirectories?: readonly string[] | undefined;
     records?: object[] | undefined;
@@ -312,6 +319,34 @@ export function prepareTreeSqlTables(contentBase: string, { config, skipDirector
     database?: object | undefined;
     audience?: "all" | "public" | undefined;
     foreignIndex?: Map<string, object> | undefined;
+    syntax?: import("./content-session.mjs").ContentSyntax | undefined;
+}): Promise<Map<string, object[]> | undefined>;
+/**
+ * Prepare authored link-check tables in each source note's audience. Public
+ * sources share one public database; GM sources share one complete database.
+ * Complete records remain available for authored-link checks.
+ *
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {object} [opts.config] - Resolved configuration.
+ * @param {readonly string[]} [opts.skipDirectories] - The walk's scope.
+ * @param {object[]} [opts.records] - Complete index records already derived.
+ * @param {Map<string, {body: string, frontmatter: object|null}>} [opts.parsed] - Parsed notes.
+ * @param {Map<string, object>} [opts.foreignIndex] - Published dependency indexes.
+ * @param {(audience: "all"|"public") => Promise<Map<string, object[]>|undefined>} [opts.prepareAudience] -
+ *   Context-bound preparation shared with other operations in the same session.
+ * @returns {Promise<Map<string, object[]>|undefined>} Prepared tables by source.
+ */
+export function prepareLinkSqlTables(contentBase: string, { config, skipDirectories, records, parsed, foreignIndex, prepareAudience }?: {
+    config?: object | undefined;
+    skipDirectories?: readonly string[] | undefined;
+    records?: object[] | undefined;
+    parsed?: Map<string, {
+        body: string;
+        frontmatter: object | null;
+    }> | undefined;
+    foreignIndex?: Map<string, object> | undefined;
+    prepareAudience?: ((audience: "all" | "public") => Promise<Map<string, object[]> | undefined>) | undefined;
 }): Promise<Map<string, object[]> | undefined>;
 /**
  * Aliases the renderer reads rather than printing.

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

@@ -11,15 +11,17 @@
  * @param {object} opts
  * @param {readonly object[]} opts.records - Index records the caller derived.
  * @param {string} [opts.contentPackage] - Named in the counts line.
+ * @param {Map<string, import("./content-session.mjs").ContentNoteSource>} [opts.parsed] - Captured sources, with the file reader as fallback.
  * @returns {{findings: object[], counts: {full: number, draft: number,
  *   stub: number}, byType: Array<{type: string, full: number, draft: number,
  *   stub: number}>, oldestDrafts: Array<{file: string, modified: Date}>,
  *   summary: string[]}} The findings, the ladder's counts, and the lines a
  *   reader is shown as prose rather than as findings.
  */
-export function lintNoteStates(contentBase: string, { records, contentPackage }?: {
+export function lintNoteStates(contentBase: string, { records, contentPackage, parsed }?: {
     records: readonly object[];
     contentPackage?: string | undefined;
+    parsed?: Map<string, import("./content-session.mjs").ContentNoteSource> | undefined;
 }): {
     findings: object[];
     counts: {

package/types/engine/word-rows.d.mts

@@ -1,13 +1,15 @@
 /**
- * A lookup from a built piece to its gloss, over the words (stems included)
- * and affixes of one or more languages.
+ * A lookup from a built piece to its gloss, over the words (stems included),
+ * affixes and elements of one or more languages.
  *
- * Languages are given nearest first: a language's own words, then its own
- * affixes, then the next language's, so a daughter's entry wins over its
- * parent's. A piece matches an entry written exactly as it is, and failing
- * that one written with the same letters and different joining hyphens, so
+ * For each spelling, languages are given nearest first: a language's own
+ * words, then its affixes and elements, then the next language's. A piece
+ * matches an exact spelling across the lineage first, and failing that one
+ * written with the same letters and different joining hyphens, so
  * `wulf-` finds the word `wulf`. Within a language a word's own gloss wins over
- * an affix's.
+ * an affix's, and both precede an element's sense. Elements also match their
+ * declared variants; affixes also match their front-vowel forms. Spelling,
+ * including case and accents, is preserved.
  *
  * @param {...object} datas - Each language note's `data`, nearest first.
  * @returns {(piece: string) => string|null} The gloss, or `null` where none resolves.