@heroiclands/package-build 23.0.0 → 23.1.1

package/engine/map-raster.mjs

@@ -1,51 +0,0 @@
-/*
- * SPDX-License-Identifier: GPL-3.0-or-later
- */
-
-import fs from "node:fs";
-import path from "node:path";
-import { Resvg } from "@resvg/resvg-js";
-import { resolvePackageBuildConfig } from "../config.mjs";
-
-/** Rasterize an authored SVG map into the staged Foundry package. */
-export function rasterizeMapSvg({ foundryPath, width, height, sceneId, config }) {
-    if (!config) throw new Error("SVG map rasterization requires the package build configuration");
-    const buildConfig = resolvePackageBuildConfig(config);
-    if (![width, height].every((value) => Number.isInteger(value) && value > 0)) {
-        throw new Error("an SVG map needs `sohl.dimensions: [width, height]` in whole pixels");
-    }
-    const marker = "/assets/";
-    const at = foundryPath.indexOf(marker);
-    if (at < 0 || !foundryPath.toLowerCase().endsWith(".svg")) {
-        throw new Error(`map art path "${foundryPath}" is not an SVG inside assets`);
-    }
-    const suffix = foundryPath.slice(at + marker.length);
-    const source = path.resolve(config.rootDir, "assets", suffix);
-    const assetRoot = path.resolve(config.rootDir, "assets");
-    if (!source.startsWith(`${assetRoot}${path.sep}`) || !fs.existsSync(source)) {
-        throw new Error(`map SVG "${foundryPath}" is not a local asset this package can rasterize`);
-    }
-    const staged = path.resolve(
-        config.rootDir,
-        buildConfig.stageDir,
-        "assets/maps/rasterized",
-        `${sceneId}.png`,
-    );
-    fs.mkdirSync(path.dirname(staged), { recursive: true });
-    try {
-        const image = new Resvg(fs.readFileSync(source), {
-            fitTo: { mode: "width", value: width },
-        }).render();
-        if (image.height !== height) {
-            throw new Error(
-                `the SVG is ${width}×${image.height} at the stated width, not ${width}×${height}`,
-            );
-        }
-        fs.writeFileSync(staged, image.asPng());
-    } catch (error) {
-        throw new Error(`could not rasterize map SVG "${foundryPath}": ${error.message}`, {
-            cause: error,
-        });
-    }
-    return `${buildConfig.packageKind}/${buildConfig.packageId}/assets/maps/rasterized/${sceneId}.png`;
-}

package/hugo-theme/layouts/partials/holdings/entry.html

@@ -1,21 +0,0 @@
-{{- /*
-  One entry of a holdings list — `{title, url, type, subType}`, as
-  `@heroiclands/package-build` derives from `contains`, `governed_by` and
-  `governed_places` (see the "holdings card" section of the README).
-
-  `url` is absent for a stub: a note with an empty body, which carries its
-  facts into every list that names it but publishes no page of its own. The
-  build omits the key outright rather than writing `url: null` — confirmed by
-  stringifying a stub entry through the same `gray-matter`/`js-yaml` path the
-  build writes frontmatter with — but `with` guards both the same way, since
-  a missing map key and an empty string both read false. This is the same
-  guard `infobox/entry.html` already applies to its own `{text, url}` shape.
-
-  Takes `entry` and the `class` its medium gives it.
-*/ -}}
-{{- $entry := .entry -}}
-{{- with $entry.url -}}
-<a class="{{ $.class }}" href="{{ . }}">{{ $entry.title }}</a>
-{{- else -}}
-<span class="{{ $.class }}">{{ $entry.title }}</span>
-{{- end -}}

package/hugo-theme/layouts/partials/holdings/kind-groups.html

@@ -1,71 +0,0 @@
-{{- /*
-  The kind-grouped body of a "Within" or "Holdings" table: its entries
-  broken into named groups by `subType`, in the closed order region,
-  settlement, site, structure, feature — the order a reader wants a place
-  hierarchy read in, not alphabetical. A `subType` outside that order, or
-  missing entirely, is grouped last, one group per remaining kind,
-  alphabetically by its `humanize`d label.
-
-  Each group is a CSS grid (`repeat(auto-fill, minmax(14em, 1fr))`, the same
-  the Related card uses) so a region with forty settlements stays scannable.
-
-  Takes the entries (a `HoldingsEntry` list). Renders nothing for an empty
-  list, so a caller can include it unconditionally once its own presence
-  check on the list has passed.
-*/ -}}
-{{- $entries := . -}}
-{{- $kindOrder := slice "region" "settlement" "site" "structure" "feature" -}}
-{{- $kindLabels := dict
-  "region"     "Regions"
-  "settlement" "Settlements"
-  "site"       "Sites"
-  "structure"  "Structures"
-  "feature"    "Features"
--}}
-
-{{- /* Bucket entries by subType, defaulting an absent one to "". */ -}}
-{{- $byKind := dict -}}
-{{- range $entries -}}
-  {{- $kind := .subType | default "" -}}
-  {{- $existing := index $byKind $kind | default slice -}}
-  {{- $byKind = merge $byKind (dict $kind ($existing | append .)) -}}
-{{- end -}}
-
-{{- /* The closed order first. */ -}}
-{{- $groups := slice -}}
-{{- $seen := slice -}}
-{{- range $kindOrder -}}
-  {{- $kind := . -}}
-  {{- with index $byKind $kind -}}
-    {{- $groups = $groups | append (dict "label" (index $kindLabels $kind) "entries" .) -}}
-    {{- $seen = $seen | append $kind -}}
-  {{- end -}}
-{{- end -}}
-
-{{- /* Anything else — a kind outside the closed set, or none at all —
-       grouped last, alphabetically by its rendered label. */ -}}
-{{- $leftover := slice -}}
-{{- range $kind, $group := $byKind -}}
-  {{- if not (in $seen $kind) -}}
-    {{- $label := humanize $kind -}}
-    {{- if eq $kind "" -}}{{- $label = "Other" -}}{{- end -}}
-    {{- $leftover = $leftover | append (dict "label" $label "entries" $group) -}}
-  {{- end -}}
-{{- end -}}
-{{- if $leftover -}}
-  {{- $leftover = sort $leftover "label" "asc" -}}
-  {{- range $leftover -}}
-    {{- $groups = $groups | append . -}}
-  {{- end -}}
-{{- end -}}
-
-{{- range $groups }}
-<div class="holdings-kind-group">
-  <h4 class="holdings-kind-label">{{ .label }}</h4>
-  <ul class="holdings-table-grid">
-    {{- range .entries }}
-    <li>{{ partial "holdings/entry.html" (dict "entry" . "class" "holdings-entry-name") }}</li>
-    {{- end }}
-  </ul>
-</div>
-{{- end -}}

package/hugo-theme/layouts/partials/holdings.html

@@ -1,61 +0,0 @@
-{{- /*
-  Geography and government card.
-
-  Three small tables, rendered after the body and before the Related card
-  (see `page-body.html`), from front matter `@heroiclands/package-build`
-  derives and a note never authors itself:
-
-    contains:  [{ title, url, type, subType }]  places sitting within this one
-    governed_by:   [{ title, url, type, subType }]  affiliations governing this place
-    governed_places:  [{ title, url, type, subType }]  places this affiliation governs
-
-  A place page carries `contains` and/or `governed_by`; an affiliation page
-  carries `governed_places`. Neither is checked here — presence of the key is the
-  only test, the same silent-disappear convention the Related card follows:
-  a page carrying none of the three renders no card at all.
-
-  `contains` and `governed_places` list places, so each is broken into groups by
-  kind (`holdings/kind-groups.html`) — the towns together, the hamlets
-  together. `governed_by` lists affiliations, whose kinds have no fixed
-  hierarchy to group by, so it stays one flat grid with the kind printed
-  beside each name instead of as a group heading.
-
-  An entry's `url` is absent for a stub — a note with an empty body, which
-  carries its facts into every list that names it but publishes no page of
-  its own. `holdings/entry.html` renders such an entry as plain text and
-  every other entry as a link — see it for the guard and how its correctness
-  was established.
-*/ -}}
-{{- $within := .Params.contains -}}
-{{- $government := .Params.governed_by -}}
-{{- $governed := .Params.governed_places -}}
-
-{{- if or $within $government $governed -}}
-<section class="holdings" data-pagefind-ignore>
-  {{- with $within }}
-  <div class="holdings-table">
-    <h3 class="holdings-table-label">Within</h3>
-    {{ partial "holdings/kind-groups.html" . }}
-  </div>
-  {{- end }}
-  {{- with $government }}
-  <div class="holdings-table">
-    <h3 class="holdings-table-label">Governed by</h3>
-    <ul class="holdings-table-grid">
-      {{- range . }}
-      <li>
-        {{- partial "holdings/entry.html" (dict "entry" . "class" "holdings-entry-name") -}}
-        {{- with .subType }}<span class="holdings-entry-kind"> ({{ humanize . }})</span>{{ end -}}
-      </li>
-      {{- end }}
-    </ul>
-  </div>
-  {{- end }}
-  {{- with $governed }}
-  <div class="holdings-table">
-    <h3 class="holdings-table-label">Governed places</h3>
-    {{ partial "holdings/kind-groups.html" . }}
-  </div>
-  {{- end }}
-</section>
-{{- end -}}

package/hugo-theme/layouts/partials/literature-works.html

@@ -1,29 +0,0 @@
-{{- /*
-  The "In song and story" card: the works of literature that name this page's
-  subject, rendered after the body and the geography and government card.
-
-  Front matter `@heroiclands/package-build` derives from every `literature`
-  lore note's `data.subjects`, and a note never authors itself:
-
-    works:  [{ title, url, form? }]  works naming this page, sorted by title
-
-  `form` is the work's `data.form` — an epic, a saga, a praise-song — printed
-  beside its name. Presence of the key is the only test: a page no work names
-  carries no `works` and renders no card. An entry with no `url` is a work
-  that publishes no page, rendered as plain text by `holdings/entry.html`.
-*/ -}}
-{{- with .Params.works -}}
-<section class="holdings literature-works" data-pagefind-ignore>
-  <div class="holdings-table">
-    <h3 class="holdings-table-label">In song and story</h3>
-    <ul class="holdings-table-grid">
-      {{- range . }}
-      <li>
-        {{- partial "holdings/entry.html" (dict "entry" . "class" "holdings-entry-name") -}}
-        {{- with .form }}<span class="holdings-entry-kind"> ({{ . }})</span>{{ end -}}
-      </li>
-      {{- end }}
-    </ul>
-  </div>
-</section>
-{{- end -}}

package/hugo-theme/layouts/partials/place-map.html

@@ -1,9 +0,0 @@
-{{- /* A page bundle's generated itinerary. The SVG carries its own place links. */ -}}
-{{- with .Params.map -}}
-  {{- with $.Resources.GetMatch . -}}
-    <section class="place-map" aria-labelledby="place-map-heading" data-pagefind-ignore>
-      <h2 id="place-map-heading" class="place-map-heading">From here</h2>
-      <div class="place-map-drawing">{{ .Content | safeHTML }}</div>
-    </section>
-  {{- end -}}
-{{- end -}}

package/types/engine/itinerary-scenes.d.mts

@@ -1,29 +0,0 @@
-/** GraphViz's plain coordinates, converted to pixel positions on its PNG. */
-export function pinPositions(plain: any, width: any, height: any): Map<any, any>;
-/**
- * Emit backgrounds into the staged package and return Scenes and the journals
- * their pins need. The caller writes them into its Scene and Adventure packs.
- */
-export function buildItineraryScenes({ config, records, contentBase, journalSourceDirs, stats, foreign, }: {
-    config: any;
-    records: any;
-    contentBase: any;
-    journalSourceDirs?: never[] | undefined;
-    stats: any;
-    foreign?: {
-        index: Map<string, object>;
-        packages: Set<string>;
-        stale: Array<{
-            package: string;
-            reason: string;
-        }>;
-    } | undefined;
-}): {
-    scenes: object[];
-    journal: any[];
-    findings: {
-        file: any;
-        severity: string;
-        message: string;
-    }[];
-};

package/types/engine/lore-events.d.mts

@@ -1,14 +0,0 @@
-/**
- * Validate one `lore` note's `data.events`.
- *
- * Registered as the `events` field's own `check` in `note-vocabulary.mjs`, so
- * it runs on every `lore` note regardless of `subType` — an occasion is not a
- * calendar fact, and nothing here is scoped to `subType: calendar`.
- *
- * @param {object} note - The note, as the link index hands it over.
- * @param {{index?: object}} [options]
- * @returns {object[]} Findings, each positioned at the entry that earned it.
- */
-export function checkLoreEvents(note: object, { index }?: {
-    index?: object;
-}): object[];

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

@@ -1,297 +0,0 @@
-/**
- * Whether a content note's type compiles into a Scene.
- *
- * @param {string} [type] - The note's `type` frontmatter.
- * @returns {boolean} True for a map type.
- */
-export function isMapType(type?: string): boolean;
-/**
- * The canvas profile for a map subType.
- *
- * Keyed on the subType rather than the type: every map note is
- * `type: map`, and which canvas it derives is the one thing the three
- * spellings ever decided.
- *
- * @param {string} subType - The note's `subType`.
- * @returns {object} The profile from {@link MAP_SUBTYPE_PROFILES}.
- * @throws {Error} When the subType is not a map subType — the build's
- *   fail-fast contract, so a typo never ships a scene with Foundry's own
- *   defaults.
- */
-export function mapProfile(subType: string): object;
-/**
- * The id of one region within its scene.
- *
- * Derived rather than stored so a cross-reference (`teleportToken`,
- * `toggleBehavior`) can be resolved to a UUID before the target scene has been
- * compiled. An authored `_id` always wins — the converter pins ids on
- * write-back exactly as it does for items and actors.
- *
- * @param {string} sceneId - The owning scene's `_id`.
- * @param {string} key - The region's authored key.
- * @param {string} [pinned] - An authored `_id`, if any.
- * @returns {string} A 16-character Foundry id.
- */
-export function regionDocId(sceneId: string, key: string, pinned?: string): string;
-/**
- * The id of one behaviour within its region.
- *
- * @param {string} regionId - The owning region's `_id`.
- * @param {string} key - The behaviour's authored key.
- * @param {string} [pinned] - An authored `_id`, if any.
- * @returns {string} A 16-character Foundry id.
- */
-export function behaviorDocId(regionId: string, key: string, pinned?: string): string;
-/**
- * A region's highlight colour, derived from its key.
- *
- * Foundry's default is `Color.fromHSV([Math.random(), 0.8, 0.8])` — a different
- * value on every create, which would make each build's output differ from the
- * last for no reason anyone could see. Hashing the key keeps builds
- * reproducible and diffs quiet, in the same hue/saturation family Foundry
- * itself would have chosen, and keeps the value out of the note entirely.
- *
- * @param {string} key - The region's authored key.
- * @returns {string} A CSS hex colour.
- */
-export function regionColor(key: string): string;
-/**
- * The map's own measurements, from which both unit lints are derived.
- *
- * @typedef {object} MapGeometry
- * @property {string} label - The authored key, for error messages.
- * @property {number} pxPerGrid - Pixels per grid square.
- * @property {number[]} dimensions - `[width, height]` in pixels.
- */
-/**
- * Reject geometry authored in grid squares where pixels belong.
- *
- * A grid-valued wall or region is not rejected by Foundry: it becomes a
- * 12x11-pixel feature in the top-left corner, invisible on the map and
- * impossible to notice in a diff. The test is derived from the map itself
- * rather than a magic number — when every coordinate of one feature is smaller
- * than a single grid square, on a map several squares across, the author
- * counted squares.
- *
- * @param {number[]} coords - The feature's coordinates, in pixels.
- * @param {MapGeometry} geom - The map's measurements.
- * @throws {Error} When the coordinates read as grid units.
- */
-export function assertPixelGeometry(coords: number[], geom: MapGeometry): void;
-/**
- * Reject a map pin authored in pixels where grid squares belong.
- *
- * @param {number[]} at - The pin's `[x, y]`, in grid squares.
- * @param {MapGeometry} geom - The map's measurements.
- * @throws {Error} When the coordinates read as pixels.
- */
-export function assertGridLocation(at: number[], geom: MapGeometry): void;
-/**
- * Compile a wall's `blocks:` / `limits:` lists into Foundry's four numeric
- * restriction fields.
- *
- * The authored vocabulary is deliberately not Foundry's.
- * `WALL_MOVEMENT_TYPES.NONE` means movement does **not** collide — i.e.
- * passable — so `movement: none` reads as the exact opposite of what it does.
- * `blocks:` says what the wall stops and `limits:` what it merely attenuates;
- * anything unnamed is passable.
- *
- * @param {{blocks?: string[], limits?: string[]}} spec - The authored lists.
- * @param {string} label - The authored key, for error messages.
- * @returns {{move: number, sight: number, light: number, sound: number}} The
- *   Wall restriction fields.
- * @throws {Error} On an unknown sense, a sense in both lists, or a *limited*
- *   movement restriction (movement is binary — it has no LIMITED value).
- */
-export function wallRestrictions(spec: {
-    blocks?: string[];
-    limits?: string[];
-}, label: string): {
-    move: number;
-    sight: number;
-    light: number;
-    sound: number;
-};
-/**
- * Compile one authored shape into a Foundry shape record.
- *
- * Four forms only — `rectangle` (`rect` is accepted as its short spelling),
- * `circle`, `ellipse` and `polygon`. The remaining six Foundry shapes are
- * template and token-attached forms with no place in an authored map, and
- * `gridBased` is deliberately not exposed: it re-interprets a shape metrically,
- * and one unit convention per note is the whole point.
- *
- * @param {object} spec - The authored shape entry.
- * @param {MapGeometry} geom - The map's measurements.
- * @returns {object} The Foundry shape record.
- * @throws {Error} On an unknown form, a degenerate polygon, or grid-unit
- *   coordinates.
- */
-export function buildShape(spec: object, geom: MapGeometry): object;
-/**
- * Compile a map note into a Scene document, embedded documents and all.
- *
- * Every embedded document carries its own `_key`. This is not decoration: the
- * compendium CLI writes each one straight to its sublevel by that key, and a
- * missing one fails the compile with `Key cannot be null or undefined`.
- *
- * @param {object} fm - The note's frontmatter.
- * @param {object} ctx - The compile context:
- *   `packageId`, `journalEntryId`, `journalPack` (the pack the note's derived
- *   JournalEntry landed in), `pageIds` (heading key → page id),
- *   `resolveRegionRef` / `resolveBehaviorRef` / `resolveEffectRef` (address →
- *   UUID), `art` (an art address → the path each surface serves),
- *   `knownActions`, `warnings`, and optionally `folder` and `stats`.
- * @returns {object} The Scene document, keyed for the pack.
- * @throws {Error} On any authoring mistake Foundry would accept silently.
- */
-export function buildScene(fm: object, ctx: object): object;
-/**
- * Synthesise the scene's single embedded Level from `img:` / `overlay:`.
- *
- * Authors never write `levels:`. A scene must ship at least one Level — the
- * client-side `_preCreate` net that would create one does not run for offline
- * pack compilation, and the server-side migration shim is version-gated on
- * `_stats.coreVersion`, so a pack stamped 14.x+ skips it and ships a scene with
- * no Level and no map.
- *
- * @param {object} sohl - The note's `sohl:` block.
- * @param {string} sceneId - The owning scene's `_id`.
- * @param {string} img - The background art, already resolved from the note's
- *   `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, 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, accepts?: Iterable<string>) => string | null): object;
-/**
- * Compile the `walls:` and `doors:` blocks into Wall documents.
- *
- * Walls are keyed by **feature** rather than by restriction signature, so a
- * diff reads "the hayloft walls changed" instead of "line 143 changed", and a
- * human can find the one wall they meant to move.
- *
- * @param {object} sohl - The note's `sohl:` block.
- * @param {MapGeometry} geom - The map's measurements.
- * @param {object} ctx - The compile context.
- * @returns {object[]} The Wall documents.
- */
-export function buildWalls(sohl: object, geom: MapGeometry, ctx: object): object[];
-/**
- * Compile the `lights:` block into AmbientLight documents.
- *
- * `dim` and `bright` are radii in the scene's **distance units** (Foundry's own
- * meaning), not pixels; only `position:` is pixels.
- *
- * @param {object} sohl - The note's `sohl:` block.
- * @param {MapGeometry} geom - The map's measurements.
- * @param {object} ctx - The compile context.
- * @returns {object[]} The AmbientLight documents.
- */
-export function buildLights(sohl: object, geom: MapGeometry, ctx: object): object[];
-/**
- * Compile the `tiles:` block into Tile documents.
- *
- * @param {object} sohl - The note's `sohl:` block.
- * @param {MapGeometry} geom - The map's measurements.
- * @param {object} ctx - The compile context.
- * @returns {object[]} The Tile documents.
- */
-export function buildTiles(sohl: object, geom: MapGeometry, ctx: object): object[];
-/**
- * Compile the `sounds:` block into AmbientSound documents.
- *
- * Positional audio is the one audio mechanism that packages cleanly: `path` is
- * a plain `FilePathField` with no document reference behind it.
- *
- * @param {object} sohl - The note's `sohl:` block.
- * @param {MapGeometry} geom - The map's measurements.
- * @param {object} ctx - The compile context.
- * @returns {object[]} The AmbientSound documents.
- */
-export function buildSounds(sohl: object, geom: MapGeometry, ctx: object): object[];
-/**
- * Compile the `locations:` block into Note documents — the map pins.
- *
- * A location's key names a heading in the note's body, and the pin points at
- * the journal page that heading compiled into. `Note.entryId` / `pageId` are
- * `{idOnly: true}` fields, which return before the compendium guard, so pin
- * targets survive packing intact — but `Note#entry` resolves by bare id against
- * the **world** collection, which is why a map with pins ships inside an
- * Adventure (`keepId: true`).
- *
- * @param {object} sohl - The note's `sohl:` block.
- * @param {MapGeometry} geom - The map's measurements.
- * @param {object} ctx - The compile context.
- * @returns {object[]} The Note documents.
- */
-export function buildLocations(sohl: object, geom: MapGeometry, ctx: object): object[];
-/**
- * Compile the `regions:` block into Region documents with their behaviours.
- *
- * @param {object} sohl - The note's `sohl:` block.
- * @param {MapGeometry} geom - The map's measurements.
- * @param {object} ctx - The compile context.
- * @returns {object[]} The Region documents.
- */
-export function buildRegions(sohl: object, geom: MapGeometry, ctx: object): object[];
-/**
- * Per-subtype canvas defaults, emitted **explicitly** on every scene.
- *
- * This is not a convenience. `grid.type`, `grid.distance` and `grid.units` all
- * declare `initial: () => game.system.grid.*`, and there is no `game` at build
- * time — left to their initial they would throw or ship undefined. The numeric
- * values are `CONST.GRID_TYPES` and `CONST.FOG_EXPLORATION_MODES`, spelled out
- * here because the constants module is Foundry's, not ours.
- *
- * @type {Readonly<Record<string, object>>}
- */
-export const MAP_SUBTYPE_PROFILES: Readonly<Record<string, object>>;
-/**
- * Foundry's own id for the level a scene is created with
- * (`Scene.metadata.defaultLevelId`). Adopting it makes every reference to the
- * synthesised level derivable, and matches what Foundry would have produced.
- */
-export const DEFAULT_LEVEL_ID: "defaultLevel0000";
-/**
- * The behaviour types a map note may carry (v1).
- *
- * @type {ReadonlySet<string>}
- */
-export const REGION_BEHAVIOR_TYPES: ReadonlySet<string>;
-/**
- * Behaviour types a map note may **never** carry, and why.
- *
- * `executeScript` is banned outright: its `source` is a `JavaScriptField`, so a
- * note carrying one would compile data into code — the system's top security
- * constraint (non-negotiable rule 10). There is no escape hatch and no
- * configuration that re-enables it. `executeMacro` is merely deferred: its
- * target Macro has to ship in the same Adventure to resolve, and
- * Adventure-bundled macros are not built yet.
- *
- * @type {ReadonlyMap<string, string>}
- */
-export const BANNED_REGION_BEHAVIOR_TYPES: ReadonlyMap<string, string>;
-/**
- * The map's own measurements, from which both unit lints are derived.
- */
-export type MapGeometry = {
-    /**
-     * - The authored key, for error messages.
-     */
-    label: string;
-    /**
-     * - Pixels per grid square.
-     */
-    pxPerGrid: number;
-    /**
-     * - `[width, height]` in pixels.
-     */
-    dimensions: number[];
-};
-import { MAP_SUBTYPES } from "./ids.mjs";
-import { MAP_TYPES } from "./ids.mjs";
-export { MAP_SUBTYPES, MAP_TYPES };

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

@@ -1,8 +0,0 @@
-/** Rasterize an authored SVG map into the staged Foundry package. */
-export function rasterizeMapSvg({ foundryPath, width, height, sceneId, config }: {
-    foundryPath: any;
-    width: any;
-    height: any;
-    sceneId: any;
-    config: any;
-}): string;