@heroiclands/package-build 22.9.2 → 22.11.0

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

@@ -1,97 +1,3 @@
-/**
- * What one system block accepts beyond the keys every block carries.
- *
- * @typedef {object} SystemBlockSpec
- * @property {readonly string[]} [known] - Keys stated outright.
- * @property {boolean} [fieldVocabulary] - Whether the note type's declared field
- *   names, as the caller's `schemas` state them, are keys of this block.
- * @property {Readonly<Record<string, readonly object[]>>} [fields] - Type → this
- *   system's own declared fields. A type it does not name is a type this system
- *   says nothing about, and its block is left unchecked on such a note rather
- *   than reported wholesale.
- */
-/**
- * Every system a configuration says its tree carries.
- *
- * **Which systems a package ships for is already declared**, in three places
- * that answer different questions, so this reads all three rather than asking a
- * new one:
- *
- * - `systems:` declares them without requiring one, which is how a
- *   package ships for several;
- * - a **pack's** `system:` is the same statement made per pack, and it is the
- *   one some trees make: `harn-ensemble` declares an `actors-sohl` and an
- *   `actors-hm3` and nothing else about either system. It is already
- *   authoritative elsewhere — `eligibleFor` fails a note for want of the block
- *   a pack's `system:` names — so a lint that did not read it would refuse a
- *   note at compile for a block it never checked;
- * - `stats.systemId` is the package-wide answer where there is one, and it has
- *   already absorbed every way of spelling that: a system package is its own
- *   system, and a module takes `requiresSystem`, its lone `systems:` entry, or
- *   its lone system relationship.
- *
- * A package naming a system in none of them is system-agnostic on purpose — its
- * packs are core document types carrying no system data — so it carries no
- * system block and naming one would invent it.
- *
- * @param {object} [config] - A resolved configuration from `defineConfig`.
- * @returns {string[]} The system ids, deduplicated, in declared order.
- */
-export function declaredSystems(config?: object): string[];
-/**
- * The system blocks a configuration says its tree carries, and what each
- * accepts.
- *
- * The lint checks the blocks its caller names, and for as long as there was one
- * system the only caller named none — so every tree took the `sohl:` of
- * {@link DEFAULT_SYSTEM_BLOCKS}, a constant, in a module whose whole discipline
- * is that it states no vocabulary of its own. That is wrong in both directions
- * the moment a second system exists, and the second direction is the worse:
- *
- * - a package shipping for `hm3` had its `hm3:` block **never looked at**, so
- *   every key in it was discarded at compile without a word — the silent-drop
- *   family this check exists to close;
- * - and the block that *was* checked was named after a system that package does
- *   not ship for, so the one finding it could make was about nothing.
- *
- * **A block's vocabulary has two sources, and a system may have both.**
- *
- * - The **note schemas** the caller hands in as `schemas`. Those belong to one
- *   system — the CLI imports `sohl/note-schemas.mjs` — and `schemaSystem` is the
- *   caller naming which, because only the caller knows. It is the only source
- *   that reaches a type no item registry declares, which is to say `being`: the
- *   2,512 notes `harn-ensemble` is made of, and the reason this is not an
- *   optional refinement.
- * - The system's **own registry**, `itemFieldsBySystem`, keyed by system and
- *   until now read by nothing. This is what a *second* system's block is held
- *   to, since the note schemas describe its neighbour.
- *
- * A system with neither is left out: nothing can state what its block may
- * carry, and holding it to an empty vocabulary would report every key in a
- * correct tree. **That is a check that does not run**, which is
- * indistinguishable from one that passed, so the caller says it out loud —
- * {@link declaredSystems} is the other half of that comparison. `harn-ensemble`
- * is the tree it names: two systems, and an `itemBuilders` registry for
- * neither, so its `hm3:` block is unchecked until it declares one.
- *
- * An earlier draft of this took the note schemas for a system's vocabulary only
- * where the package declared **one** system, on the reasoning that with several
- * there is nothing to say which one they describe. There is: the caller, which
- * chose them. The guess cost `harn-ensemble` its whole `sohl:` check — two
- * systems declared, so the fallback never fired — which is the coverage this
- * change exists to widen rather than narrow.
- *
- * @param {object} [config] - A resolved configuration from `defineConfig`.
- * @param {object} [options] - Options.
- * @param {string} [options.schemaSystem] - The system whose vocabulary the
- *   caller's `schemas` state. There are two systems, not an open set, so this is
- *   one word from the caller rather than a mechanism.
- * @returns {Readonly<Record<string, SystemBlockSpec>>} The blocks to check, in
- *   declared order. A system nothing states the vocabulary of is absent.
- */
-export function systemBlocksFor(config?: object, { schemaSystem }?: {
-    schemaSystem?: string | undefined;
-}): Readonly<Record<string, SystemBlockSpec>>;
 /**
  * Whether a value satisfies a declared {@link FieldSpec.kind}.
  *
@@ -103,9 +9,10 @@ export function systemBlocksFor(config?: object, { schemaSystem }?: {
  *
  * @param {unknown} value - The authored value.
  * @param {string} kind - The declared kind.
+ * @param {object} [context] - Complete Address defaults and known type vocabulary.
  * @returns {boolean} Whether it is acceptable.
  */
-export function matchesKind(value: unknown, kind: string): boolean;
+export function matchesKind(value: unknown, kind: string, context?: object): boolean;
 /**
  * Check one note against its type's schema.
  *
@@ -113,7 +20,7 @@ export function matchesKind(value: unknown, kind: string): boolean;
  * @param {object} opts
  * @param {Record<string, readonly object[]>} opts.schemas - Type → declaration.
  * @param {object} [opts.index] - The link index, for the reference check, which
- *   runs through its `referenceHit`. Its absence skips that check rather than
+ *   runs through its `shortcodeHit`. Its absence skips that check rather than
  *   reporting every reference as dead.
  * @param {Record<string, object>} [opts.vocabulary] - Type → the closed regions
  *   it declares, as `engine/note-vocabulary.mjs` states them. Supplied
@@ -132,13 +39,14 @@ export function matchesKind(value: unknown, kind: string): boolean;
  *   for the same reason `schemas` is — a build derives them from its
  *   configuration through {@link systemBlocksFor}, and this module states no
  *   system name of its own. See {@link DEFAULT_SYSTEM_BLOCKS} for the fallback.
+ * @param {object} [opts.addressContext] - Builder package and Address type vocabulary.
  * @param {readonly string[]} [opts.packs] - The pack names this package
  *   declares, for a `data:` field whose map is keyed by pack. Supplied by the
  *   caller like `schemas` and `vocabulary`, and absent it no claim is made
  *   about those keys.
  * @returns {object[]} Findings, each with a locator where one is obtainable.
  */
-export function lintNote(note: object, { schemas, index, vocabulary, packs, emittedArt, systems }: {
+export function lintNote(note: object, { schemas, index, vocabulary, packs, emittedArt, addressContext, systems, }: {
     schemas: Record<string, readonly object[]>;
     index?: object | undefined;
     vocabulary?: Record<string, object> | undefined;
@@ -147,6 +55,7 @@ export function lintNote(note: object, { schemas, index, vocabulary, packs, emit
         art: readonly string[];
     } | null) | undefined;
     systems?: Readonly<Record<string, SystemBlockSpec>> | undefined;
+    addressContext?: object | undefined;
     packs?: readonly string[] | undefined;
 }): object[];
 /**
@@ -280,3 +189,4 @@ export type SystemBlockSpec = {
      */
     fields?: Readonly<Record<string, readonly object[]>> | undefined;
 };
+export { declaredSystems, systemBlocksFor } from "./system-vocabulary.mjs";

package/types/engine/frontmatter.d.mts

@@ -32,16 +32,31 @@ export function sohlField(fm: any, key: any, defaultValue?: undefined): any;
  * has to be told both. It is the same split `FieldSpec.name`/`legacyKey` makes,
  * for the same reason — one name cannot key two positions.
  *
+ * `shared` is the field's declared shared source, and it completes the order the
+ * three other positions are two thirds of. A field whose source is a path into
+ * `data:` is authored there by the specification's own mapping tables, and a
+ * reader that knew the destination, the block and the top level alone skipped
+ * straight past the container: every authored value read as unset, and the
+ * document shipped the field's default with nothing said. It sits **between**
+ * the block and the top level, exactly where
+ * {@link module:engine/system-block.resolveFieldValue} puts it — the block is the
+ * position a tree still writes and wins while it does, and the bare top-level
+ * key is the spelling `data:` gathered the fact off.
+ *
  * @param {object} fm - The note's frontmatter.
  * @param {string} to - The key at the destination, dotted for a nested one.
  * @param {any} [defaultValue] - What an unauthored field reads as.
  * @param {object} [options] - Options.
  * @param {string} [options.legacyKey] - The key the block still carries, when
  *   it is not spelled `to`. Defaults to `to`.
+ * @param {string} [options.shared] - The field's declared shared source, when it
+ *   is a path into a container (`data.relations`). Omitted by a field whose
+ *   shared position is the note's top level, which `sohlField` already reads.
  * @returns {any} The value.
  */
-export function sohlSystemField(fm: object, to: string, defaultValue?: any, { legacyKey }?: {
+export function sohlSystemField(fm: object, to: string, defaultValue?: any, { legacyKey, shared }?: {
     legacyKey?: string | undefined;
+    shared?: string | undefined;
 }): any;
 /**
  * Resolve the `charges` block shared by Mystery and Mystical Ability items.

package/types/engine/helpers.d.mts

@@ -10,7 +10,7 @@
  * `{ frontmatter: null, body: "", description: "" }` with a warn log, and no
  * position: there is no body to have one.
  */
-export function parseMarkdownFile(filePath: any): {
+export function parseMarkdownFile(filePath: any, { addressContext }?: {}): {
     frontmatter: null;
     body: string;
     description: string;
@@ -85,7 +85,7 @@ export function assertSuppliedCorpus(records: readonly object[] | undefined, who
  * @throws {Error} When `skipDirectories` is not stated — see
  *   {@link assertStatedScope}.
  */
-export function walkMarkdownTree(rootDir: string, { skipDirectories }?: {
+export function walkMarkdownTree(rootDir: string, { skipDirectories, addressContext }?: {
     skipDirectories: readonly string[];
 }): Generator<{
     file: string & NonSharedBuffer;

package/types/engine/infobox.d.mts

@@ -5,6 +5,12 @@
  * `<type>.<field>` wins over the bare name, so a spelling two types use for two
  * quantities can be said differently on each without splitting the overlay.
  *
+ * **Keyed by the key an author writes, not by the path a declaration names.**
+ * One fact has two declarations — the note vocabulary's `weight` and an item
+ * field's `data.weight` — and the overlay says what a *reader* is shown, which
+ * is one word either way. So the container is dropped before the lookup, and
+ * `GEAR_UNITS` answers for both sides with one entry.
+ *
  * @param {Readonly<Record<string, object>>} presentation - The overlay.
  * @param {string|undefined} type - The note's type.
  * @param {string} name - The field's declared name.

package/types/engine/item-docs.d.mts

@@ -1,38 +1,3 @@
-/**
- * Every content type whose **prose compiles into a JournalEntry of its own**,
- * addressed by the virtual `doc<type>` qualifier.
- *
- * Every item type, every actor type, every map type, plus `macro` — a macro
- * note's body documents the script the note also compiles into a Macro, which
- * is the same shape as an item and its description: one note, two documents,
- * the prose living in the journals pack.
- *
- * **One set, read by the compiler and the emitter alike.** The journals pass
- * decides what to compile from it, and the link manifest decides what to
- * publish a `doc<type>` entry for. Held apart, the two drift into a manifest
- * that asserts documentation nothing compiled — or a compiled entry no
- * consumer can address. It is composed exactly once, in `defineConfig`, and
- * read from there — never recomposed at a call site.
- *
- * `doc` notes are absent, for the reason that applies to them alone: a `doc`
- * note's single document *is* its prose, so there is no second document for a
- * `doc<type>` address to name.
- *
- * An accessor rather than a hoisted constant, so that importing this module
- * needs no configuration (#2).
- *
- * @returns {ReadonlySet<string>} The configured doc-carrying types.
- */
-export function docEntryTypes(): ReadonlySet<string>;
-/**
- * Whether a content note's type is one whose prose becomes a JournalEntry of
- * its own.
- *
- * @param {string} type - The note's `type` frontmatter.
- * @returns {boolean} True for an item type, an actor type, a map type and
- *   `macro`; false for `doc`.
- */
-export function hasDocEntry(type: string): boolean;
 /**
  * The id of the JournalEntry a note's prose compiles into — an item's, or a
  * macro's.
@@ -72,3 +37,4 @@ export function itemDocEntryId(itemId: string): string;
 export function itemDocPointer(packageId: string, itemId: string, name: string, firstPageId: string): string;
 export { itemTypes };
 import { itemTypes } from "./item-registry.mjs";
+export { docEntryTypes, hasDocEntry } from "./address.mjs";

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

@@ -161,12 +161,12 @@ export function buildScene(fm: object, ctx: object): object;
  *   `bgImage` address by {@link buildScene}. Passed rather than resolved here,
  *   because an address is answered by the compile's index and this function
  *   takes none.
- * @param {(value: unknown, key: string, type: string) => string|null} [art] -
+ * @param {(value: unknown, key: string, type: string, accepts?: Iterable<string>) => string|null} [art] -
  *   The art resolver, for the foreground overlay. Omitted, a note naming one
  *   gets no overlay rather than a path nothing serves.
  * @returns {object} The Level document, keyed for the pack.
  */
-export function buildLevel(sohl: object, sceneId: string, img: string, art?: (value: unknown, key: string, type: string) => string | null): object;
+export function buildLevel(sohl: object, sceneId: string, img: string, art?: (value: unknown, key: string, type: string, accepts?: Iterable<string>) => string | null): object;
 /**
  * Compile the `walls:` and `doors:` blocks into Wall documents.
  *

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

@@ -0,0 +1,41 @@
+/**
+ * All declared Address positions of a note, including embedded notes.
+ * @param {object} fm - The note.
+ * @returns {object[]} Position descriptors with container shape and defaults.
+ */
+export function addressPositions(fm: object, context?: {}): object[];
+/**
+ * Decode declared properties at the note boundary. Raw mappings cannot impersonate tuples.
+ * @param {object} fm - Parsed YAML or an index record.
+ * @param {object} context - The builder's package and known types.
+ * @returns {object} The same note carrying typed Address properties.
+ */
+export function decodeNoteAddresses(fm: object, context: object): object;
+/**
+ * Read context supplied by the package configuration.
+ * @param {object} config - Resolved package configuration.
+ * @returns {object} Builder defaults and system declarations.
+ */
+export function noteAddressContext(config: object): object;
+/**
+ * Decode Address properties contributed by an index record.
+ * @param {object} record - The record.
+ * @param {object} context - Builder defaults.
+ * @returns {object} The typed record.
+ */
+export function decodeIndexAddresses(record: object, context: object): object;
+/** Structured positions whose Address is nested inside a declared container. */
+export const STRUCTURED_ADDRESSES: readonly ({
+    path: string[];
+    shape: string;
+    type: string;
+    accepts: string[];
+    noteType?: undefined;
+} | {
+    noteType: string;
+    path: string[];
+    shape: string;
+    type: string;
+    accepts: string[];
+})[];
+export { AddressEntries, encodeAddresses, cloneAddressState } from "./address-values.mjs";

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

@@ -279,7 +279,23 @@ export type DataFieldSpec = {
      * value — which is the honest answer wherever the specification's stated
      * shape and the shape notes are authored in today disagree.
      */
-    kind?: "string" | "number" | "boolean" | "map" | "list" | "scalar-or-map" | undefined;
+    kind?: "string" | "number" | "boolean" | "map" | "list" | "scalar-or-map" | "address" | "shortcode" | undefined;
+    /**
+     * - Type of each list or pack-map value.
+     */
+    entryKind?: "address" | "shortcode" | undefined;
+    /**
+     * - Type of each map key.
+     */
+    keyKind?: "address" | "shortcode" | undefined;
+    /**
+     * - An alternative `subType:<skill-subtype>` key.
+     */
+    keySelector?: "subType" | undefined;
+    /**
+     * - Allowed Address types, separate from `ref`.
+     */
+    accepts?: readonly string[] | undefined;
     /**
      * - Human-readable shape, for a finding and for
      * documentation.
@@ -293,10 +309,11 @@ export type DataFieldSpec = {
      */
     entryShape?: string | undefined;
     /**
-     * - The type a bare value takes. An art slot declares
+     * - The Address's default type, an art slot declares
      * one — `icon` for `icon` and `tokenIcon`, `image` for `bgImage` and
      * `banner` — so `icon: anvil` names `icon-anvil` while a value carrying the
-     * separator states its own address.
+     * separator states its own address. Distinct from a `FieldSpec`'s `code`
+     * ({@link module :engine/field-spec}), which names a **Shortcode** instead.
      */
     ref?: string | undefined;
     /**

package/types/engine/place-relations.d.mts

@@ -9,7 +9,7 @@ export function oppositeBearing(bearing: unknown): string | undefined;
 /**
  * Check a place note's `data.borders`.
  *
- * Every `to` is a shortcode a place declares, every `bearing` is one of the
+ * Every `to` is an Address a place declares, every `bearing` is one of the
  * eight, no pair is listed twice, no target is the note's own parent or child,
  * and the other end states the pair back at the opposite bearing — a missing
  * reciprocal is a warning naming both notes, a wrong one an error.
@@ -38,6 +38,17 @@ export function checkBorders(note: object, { index }?: {
 export function checkRoutes(note: object, { index }?: {
     index?: object | undefined;
 }): object[];
+/**
+ * The type a border's or a route's `to` names.
+ *
+ * It is both the default its `<type>` segment takes when an author omits it and
+ * the whole of the set the position accepts, which is what makes `vylar` and
+ * `place-vylar` the same Address and a `to` naming a `lore` note an error rather
+ * than a lookup that quietly finds nothing.
+ *
+ * @type {string}
+ */
+export const RELATION_TYPE: string;
 /**
  * The eight compass bearings, clockwise from north.
  *

package/types/engine/populations.d.mts

@@ -1,3 +1,14 @@
+/**
+ * Read a fetched index entry into a node, or `null` where it takes no part.
+ *
+ * A fetched entry carries the structure its record stated and no figure, so
+ * a dependency's place sits in the geography and counts nobody.
+ *
+ * @param {string} canonical - The entry's address.
+ * @param {object} entry - The entry.
+ * @returns {PopulationNode|null} The node.
+ */
+export function foreignNode(canonical: string, entry: object): PopulationNode | null;
 /**
  * Check a place's population against the corpus around it.
  *
@@ -114,8 +125,12 @@ export type Corpus = {
      */
     holdersOf: Map<string, string[]>;
     /**
-     * `type-shortcode` → the node,
-     * for the citation rule.
+     * `type/shortcode` → the
+     * node, for the citation rule.
+     * Package-blind by design: a
+     * local note shadows a
+     * dependency's, so this is
+     * never a canonical Address.
      */
     byAddress: Map<string, PopulationNode>;
 };

package/types/engine/reference-targets.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Names and published destinations for reference presentation.
+ * Stubs contribute names, never pages or documents. The published index
+ * remains separate so body-link validation retains its publication rules.
+ * @param {readonly object[]} records - Decoded local or fetched records.
+ * @param {Map<string, object>} [published] - Actual published link destinations.
+ * @returns {Map<string, object>} Canonical lookup keys and presentation values.
+ */
+export function buildReferenceTargets(records: readonly object[], published?: Map<string, object>): Map<string, object>;

package/types/engine/shortcode-references.d.mts

@@ -0,0 +1,14 @@
+/**
+ * Present a native Shortcode using its unique system/type target.
+ * Address properties never use this lookup. Multiple packages claiming the
+ * same native identity remain ambiguous. Documentation supplies links; the
+ * native target supplies a name even when its documentation is unpublished.
+ * @param {readonly Map<string, object>[]} indexes - Published identity indexes.
+ * @param {unknown} code - Native Shortcode.
+ * @param {{type: string, system: string}} hint - Its declared native namespace.
+ * @returns {object|undefined} Documentation presentation, or no unique target.
+ */
+export function resolveShortcodeReference(indexes: readonly Map<string, object>[], code: unknown, hint: {
+    type: string;
+    system: string;
+}): object | undefined;

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

@@ -111,7 +111,7 @@ export function writeHomepages(outRoot: string, pages: readonly object[], config
  * @param {object} options.config - The resolved build configuration.
  * @returns {object} The gate results and, when they pass, the built index.
  */
-export function siteGates(pages: object[], findings: object, { config }: {
+export function siteGates(pages: object[], findings: object, { config, records }: {
     config: object;
 }): object;
 /**
@@ -185,7 +185,7 @@ export function tableUniverse(pages: object[]): Map<string, object[]>;
  * @param {object} options
  * @param {(data: object, page: object) => void} [options.decorate] - Called
  *   with each page's frontmatter, for whatever a consumer's own pass adds.
- * @param {(value: unknown, type: string) => string|null} [options.artSrc] -
+ * @param {(value: unknown, type: string, accepts?: Iterable<string>) => string|null} [options.artSrc] -
  *   Translates an art address into the pathname the website resolver takes, or
  *   `null` where nothing answers it.
  * @param {(src: string) => string} [options.webSrc] - Translates an authored
@@ -196,7 +196,7 @@ export function tableUniverse(pages: object[]): Map<string, object[]>;
  */
 export function pageFrontmatter(page: object, { decorate, webSrc, artSrc }: {
     decorate?: ((data: object, page: object) => void) | undefined;
-    artSrc?: ((value: unknown, type: string) => string | null) | undefined;
+    artSrc?: ((value: unknown, type: string, accepts?: Iterable<string>) => string | null) | undefined;
     webSrc?: ((src: string) => string) | undefined;
 }): object;
 /**

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

@@ -13,7 +13,7 @@
  *   ordinary dead address.
  * @returns {SiteIndex} The index, and what could not be addressed unambiguously.
  */
-export function buildSiteIndex(entries: readonly SiteEntry[], { foreignIndex, noIndexPackages }?: {
+export function buildSiteIndex(entries: readonly SiteEntry[], { foreignIndex, noIndexPackages, package: builderPackage, records, foreignReferences, }?: {
     foreignIndex?: Map<string, {
         package: string;
         type?: string;
@@ -62,36 +62,15 @@ export function wikiContext(built: SiteIndex, { src, file, type, errors, foreign
     resolved?: object[] | undefined;
 }): object;
 /**
- * Resolve one infobox reference against a site index.
- *
- * A note writes a reference three ways and all three reach here: a bare
- * **shortcode** (`slntlncmpny`), a short **address** (`affiliation-slntlncmpny`)
- * and a **canonical** one (`sohl-sohl-skill-melee`). The first is the ordinary
- * case and the ambiguous one — a shortcode is unique within a type and not
- * across a tree — so a caller that knows what it expects passes `hint.type`
- * and the lookup is narrowed to it.
- *
- * **Without a hint the types are tried in sorted order**, so two trees holding
- * the same note resolve it the same way. A shortcode two types both claim
- * answers with the first alphabetically, which is a stable wrong answer rather
- * than an unstable one; a caller that cares supplies the hint.
- *
- * The `address` on the answer is the slug form — `type-shortcode` — because
- * that is what the book's own link map is keyed by and what a wikilink is
- * written as.
- *
- * @param {SiteIndex} siteIndex - The index.
- * @param {unknown} ref - The reference, as authored.
- * @param {object} [hint] - `{type}`, where the caller knows it.
- * @returns {{name?: string, url?: string, address?: string, subType?: string}|undefined}
- *   The page, or `undefined` where nothing answers.
+ * Resolve one Address against the site's canonical identity index.
+ * A bare Shortcode requires a declared default type. The returned Address is
+ * the complete tuple; URL and display name are presentation values.
+ * @param {SiteIndex} siteIndex - The site index.
+ * @param {unknown} ref - Tuple or authored reference.
+ * @param {object} [hint] - A declared default type.
+ * @returns {object|undefined} The matching page and tuple.
  */
-export function resolveInfoboxRef(siteIndex: SiteIndex, ref: unknown, hint?: object): {
-    name?: string;
-    url?: string;
-    address?: string;
-    subType?: string;
-} | undefined;
+export function resolveInfoboxRef(siteIndex: SiteIndex, ref: unknown, hint?: object): object | undefined;
 /**
  * One page the site will publish, as the index needs to see it.
  */

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

@@ -63,7 +63,7 @@ export function findSqlBlocks(markdown: string): Array<{
  * @returns {Promise<{query: (sql: string) => Promise<object[]>,
  *   close: () => Promise<void>}>} The open database.
  */
-export function openNotesDatabase(records: object[], { dir, dependencies }?: {
+export function openNotesDatabase(records: object[], { dir, dependencies, addressContext }?: {
     dir?: string | undefined;
     dependencies?: {
         id: string;
@@ -111,7 +111,7 @@ export function runSqlQuery(db: object, sql: string): Promise<{
 export function renderSqlTable(result: {
     columns: string[];
     rows: object[];
-}, { linkable, sectionLevel }?: {
+}, { linkable, sectionLevel, addressContext }?: {
     linkable?: ((ref: string) => boolean) | undefined;
     sectionLevel?: number | undefined;
 }): string;

package/types/engine/system-block.d.mts

@@ -140,6 +140,23 @@ export function legacyKeyOf(field: {
 export function retiredTopLevelKey(field: {
     name?: string;
 }): string | undefined;
+/**
+ * A shared source as the key an author writes, without the container holding it.
+ *
+ * `data.weight` is authored as `weight:` one level inside `data:`, so every
+ * question about the *note* rather than about the resolution order asks it under
+ * that spelling: which presentation overlay a row takes, which key a finding
+ * names, and whether two statements of one fact are the same fact. The
+ * specification's mapping tables write the whole path and a `data:` vocabulary
+ * writes the key, and this is what makes the two comparable.
+ *
+ * It takes a **name** rather than a declaration because both sides of that
+ * comparison reach it: one holds a field, the other a row of a table.
+ *
+ * @param {string|undefined} name - The shared source, as either side spells it.
+ * @returns {string} The key, without the container.
+ */
+export function authoredKey(name: string | undefined): string;
 /**
  * Where a declared field's value came from.
  *

package/types/engine/system-vocabulary.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Systems named by package declarations and pack targets.
+ * @param {object} [config] - Resolved build configuration.
+ * @returns {string[]} Declared system identifiers.
+ */
+export function declaredSystems(config?: object): string[];
+/**
+ * System field vocabularies supplied by the configuration and caller.
+ * @param {object} [config] - Resolved build configuration.
+ * @param {object} [options] - Caller schema context.
+ * @param {string} [options.schemaSystem] - Owner of the caller's schemas.
+ * @returns {object} System block declarations.
+ */
+export function systemBlocksFor(config?: object, { schemaSystem }?: {
+    schemaSystem?: string | undefined;
+}): object;

package/types/engine/wikilink-syntax.d.mts

@@ -167,6 +167,13 @@ export function linkFindingMessage({ reason, target, packages, anchor, type, stu
  * @returns {boolean} True when the link is same-page.
  */
 export function isSamePage({ target, anchor }: ParsedWikilink): boolean;
+/**
+ * Read an operational link target in its enclosing Address context.
+ * @param {string} inner - Lexical link contents.
+ * @param {object} context - Builder defaults and type vocabulary.
+ * @returns {object} Typed target and diagnostic source spelling.
+ */
+export function readWikilink(inner: string, context: object): object;
 /**
  * What a `[[…]]` **is**, before anything decides where it points.
  *