@heroiclands/package-build 21.0.0 → 21.2.0

package/types/engine/subtype-registry.d.mts

@@ -47,6 +47,26 @@ export function schemaSubtypeOf(system: string | undefined, type: string): strin
  * @type {readonly import("./document-subtypes.mjs").DocumentSubtypeMap[]}
  */
 export const KNOWN_DOCUMENT_SUBTYPE_MAPS: readonly import("./document-subtypes.mjs").DocumentSubtypeMap[];
+/**
+ * The map a pack declaring no `system:` compiles its documents against.
+ *
+ * A pack names the system its documents are shaped for, and one declaring none
+ * is compiled by the fallback pass for its document type — a single-system
+ * package's ordinary arrangement, and the one `sohl-thalorna` ships. That pass
+ * follows one map whatever a note carries, which makes this the answer to "a
+ * document compiled here belongs to *which* system?" wherever a pack has not
+ * said.
+ *
+ * Stated here rather than read off the compiler classes because those are not
+ * reachable from a leaf: `engine/item-compiler.mjs` imports the journals pass,
+ * which draws infoboxes, so anything the infobox reads cannot import a pass.
+ * `tests/default-document-subtypes.test.ts` holds this to `compilerFor`, which
+ * is where the fallback is actually decided — so the two cannot drift apart in
+ * silence.
+ *
+ * @type {import("./document-subtypes.mjs").DocumentSubtypeMap}
+ */
+export const DEFAULT_DOCUMENT_SUBTYPES: import("./document-subtypes.mjs").DocumentSubtypeMap;
 /**
  * Every note type any shipped map compiles into an **Actor**.
  *

package/types/engine/web-wikilinks.d.mts

@@ -66,15 +66,25 @@ export function frontmatterWikilinks(fm: unknown): Array<{
  * web pages, so the author wrote a real address and there is simply nothing to
  * link to.
  *
+ * ## Embeds first, and they are not links
+ *
+ * `![[address|label]]` names a file rather than a note, so it is resolved into
+ * an ordinary markdown image before anything looks for a link — which is what
+ * stops the link pass reading an embed's interior as a link to a note nobody
+ * wrote. The image the rewrite leaves behind is what
+ * {@link module:engine/content-images.renderImageFigures} turns into a figure
+ * for the website, and what the book reads its staging list out of.
+ *
  * @param {string} body - The markdown body.
- * @param {object} ctx - `{ index, collide, sections, contentTypes, packages,
- *   foreign, type, errors, src, file }`.
+ * @param {object} ctx - `{ index, assets, collide, sections, contentTypes,
+ *   packages, foreign, type, errors, src, file }`.
  *   `packages` is every package an address may name, without which the leading
  *   package segment of a canonical address reads as an unknown type; `foreign`
- *   is the cross-package manifest index. `src` is the page's display
+ *   is the cross-package manifest index; `assets` is the address space an embed
+ *   resolves against. `src` is the page's display
  *   path and `file` the source file a diagnostic should name — absent, `src`
  *   stands in.
- * @returns {string} The body with wikilinks rewritten.
+ * @returns {string} The body with embeds and wikilinks rewritten.
  */
 export function resolveWebWikilinks(body: string, ctx: object): string;
 export { slugify };

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

@@ -128,15 +128,18 @@ export function ambiguousAddressMessage(target: string, packages?: Iterable<stri
  * @param {Iterable<string>} [finding.packages] - For `ambiguous`, the
  *   claimants.
  * @param {string} [finding.anchor] - For `unknown-anchor`, the section named.
+ * @param {string} [finding.type] - For `not-an-asset`, the type the address
+ *   named.
  * @returns {string} The message.
  * @throws {Error} On a reason outside the closed set — a resolver inventing one
  *   would otherwise report a link with no explanation at all.
  */
-export function linkFindingMessage({ reason, target, packages, anchor }: {
+export function linkFindingMessage({ reason, target, packages, anchor, type }: {
     reason: string;
     target: string;
     packages?: Iterable<string> | undefined;
     anchor?: string | undefined;
+    type?: string | undefined;
 }): string;
 /**
  * Whether a parsed link addresses a section of the page it is written on.
@@ -193,6 +196,13 @@ export function isSamePage({ target, anchor }: ParsedWikilink): boolean;
  * unclosed `[[` is a typo, and the alternative is letting it swallow arbitrary
  * prose in search of a closer. Erring towards "not a link" leaves the author's
  * text as written, which is the safe direction for a rewriter.
+ *
+ * **A leading `!` makes it an embed, not a link**, and the lookbehind is what
+ * keeps every reader from seeing one as the other. Stated here rather than in
+ * each reader for the reason the rest of this module exists: the checker, the
+ * pack compilers and the web resolver all match on this pattern, and three
+ * copies of the exclusion is three places for it to be forgotten. An embed's
+ * own grammar is {@link module:engine/content-embeds}.
  */
 export const WIKILINK: RegExp;
 /**
@@ -207,7 +217,9 @@ export const WIKILINK: RegExp;
  *
  * - `unlabelled` — no `|`, so the link addresses nothing.
  * - `not-an-address` — labelled, but the target does not parse as an address.
+ * - `not-lowercase` — a package, system or type segment carries a capital.
  * - `unknown-type` — definitely qualified, but names no type this build knows.
+ * - `not-an-asset` — a real address, embedded where only a file can be drawn.
  * - `unresolved` — parses as an address, and nothing publishes it.
  * - `ambiguous` — more than one package publishes the short address.
  * - `unknown-anchor` — the address resolved, the `#section` it names did not.

package/types/engine/wikilinks.d.mts

@@ -128,6 +128,10 @@ export function anchorPageId(noteId: string, anchorSlug: string): string;
  *   vendored manifests of packages this build links into but does not publish.
  * @param {string} [contentPackage] - This build's *content* package, which an
  *   authored address may name explicitly. Defaults to `packageId`.
+ * @param {object} [opts] - Options.
+ * @param {Map<string, object>} [opts.assets] - The files this package ships, by
+ *   canonical address. They resolve no link — an asset is not a document — and
+ *   answer only the art fields, which name a file and never a document.
  * @returns {{byShortcode: Map<string, object>, types: Set<string>}} `types` is
  *   every type the tree actually contains, so a qualifier naming no real type
  *   can be told apart from a missing target.
@@ -140,7 +144,9 @@ export function buildWikilinkIndex(docs: Array<{
     pack?: string;
     docPack?: string;
     draft?: boolean;
-}>, packageId: string, foreign?: Map<string, object>, contentPackage?: string): {
+}>, packageId: string, foreign?: Map<string, object>, contentPackage?: string, { assets }?: {
+    assets?: Map<string, object> | undefined;
+}): {
     byShortcode: Map<string, object>;
     types: Set<string>;
 };

package/types/sohl/actors.d.mts

@@ -56,7 +56,6 @@ export class Actors extends SystemActorCompiler {
         system: {
             shortcode: any;
             templatePriority: number | null;
-            portrait: any;
             appearance: string;
             dossier: string;
         };