magick-components 0.0.0-stage → 0.1.0

package/lib/gd/hall/art/lights.d.ts

@@ -0,0 +1,13 @@
+import type { HallArt, HallNode } from "../types.ts";
+import { type LightColor } from "../vocabulary.ts";
+/**
+ * A light's colour: its `light`, else the default of its kind (a lamp
+ * red, a lantern yellow). Halls written before stage H named the glass
+ * with `fill`, which still counts when it is one of the light colours.
+ */
+export declare function lightColor(node: HallNode, fallback: LightColor): "red" | "white" | "yellow";
+export declare const provenance: import("../types.ts").HallArtProvenance;
+/** A lamp (`item(kind="lamp")`), red unless its `light` says otherwise. */
+export declare const lampArt: HallArt;
+/** A lantern (`item(kind="lantern")`), yellow unless `light` says otherwise. */
+export declare const lanternArt: HallArt;

package/lib/gd/hall/art/lights.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { enumAttr } from "../attributes.js";
+import { LIGHT_COLORS } from "../vocabulary.js";
+import { pathPoint } from "./geometry.js";
+import { HIGHLIGHT, ITEM_DETAIL, ITEM_OUTLINE, original, PALETTE, } from "./shared.js";
+const GLASS = new Map([
+    ["red", PALETTE.glassRed],
+    ["yellow", PALETTE.glassYellow],
+    ["white", PALETTE.glassWhite],
+]);
+/**
+ * A light's colour: its `light`, else the default of its kind (a lamp
+ * red, a lantern yellow). Halls written before stage H named the glass
+ * with `fill`, which still counts when it is one of the light colours.
+ */
+export function lightColor(node, fallback) {
+    return (enumAttr(node, "light", LIGHT_COLORS) ??
+        enumAttr(node, "fill", LIGHT_COLORS) ??
+        fallback);
+}
+/** The attribute the lamp and the lantern add to an item's. */
+const LIGHT_ATTRIBUTES = new Map([
+    ["light", { kind: "enum", values: LIGHT_COLORS }],
+]);
+export const provenance = original("A lantern drawn from geometry: a ring, a roof, glazed panes in the " +
+    "colour of its light, a flame, a stepped base.");
+/** A teardrop flame `h` tall, centred on the axis at `cy`. */
+function flame(cy, h) {
+    const w = h * 0.36;
+    const top = cy - h / 2;
+    const bottom = cy + h / 2;
+    const shoulder = top + h * 0.42;
+    const p = (x, y) => pathPoint([x, y]);
+    return (`M${p(0, top)}C${p(w * 1.1, shoulder)} ${p(w, bottom)} ${p(0, bottom)}` +
+        `C${p(-w, bottom)} ${p(-w * 1.1, shoulder)} ${p(0, top)}Z`);
+}
+const FLAME = flame(10, 18);
+const FLAME_CORE = flame(12.88, 9);
+const PANES = "M-11,-18H11V29H-11ZM-19.5,-18H-14.5V29H-19.5ZM14.5,-18H19.5V29H14.5Z";
+/** The lantern, its panes glazed in the colour of its light. */
+function Lantern({ glass }) {
+    return (_jsxs("g", { ...ITEM_OUTLINE, children: [_jsx("circle", { cy: -45, r: 3, fill: "none", strokeWidth: ITEM_DETAIL }), _jsx("path", { d: "M-6,-41H6L26,-28H-26Z", fill: PALETTE.bronze }), _jsx("rect", { x: -28, y: -28.5, width: 56, height: 5, rx: 1.5, fill: PALETTE.bronze }), _jsx("rect", { x: -22.5, y: -23.5, width: 45, height: 57, fill: PALETTE.bronze }), _jsx("path", { d: PANES, fill: glass, strokeWidth: ITEM_DETAIL }), _jsx("path", { d: FLAME, fill: PALETTE.flame, stroke: PALETTE.fire, strokeWidth: ITEM_DETAIL }), _jsx("path", { d: FLAME_CORE, fill: PALETTE.air, stroke: "none" }), _jsx("path", { d: "M-22.5,33.5H22.5L26.5,40H-26.5Z", fill: PALETTE.bronze }), _jsx("rect", { x: -27.5, y: 40, width: 55, height: 6.5, rx: 1.5, fill: PALETTE.bronze }), _jsx("path", { d: "M-3.5,-37.5L-16,-30", ...HIGHLIGHT })] }));
+}
+/**
+ * The lamp and the lantern: one drawing, as in the old drawings, whose
+ * lanterns were the lamp stretched. They stay two kinds because their
+ * default scales and colours differ (a lamp is red and 0.94 squares
+ * tall, a lantern yellow and 2.38), and saved halls and the presets name
+ * both. `light` picks the colour of either.
+ */
+const lightArt = (fallback) => {
+    const glassOf = (node) => GLASS.get(lightColor(node, fallback));
+    return {
+        Component: ({ node }) => _jsx(Lantern, { glass: glassOf(node) }),
+        box: { width: 60.09, height: 100 },
+        attributes: LIGHT_ATTRIBUTES,
+        variant: (node) => lightColor(node, fallback),
+        provenance,
+    };
+};
+/** A lamp (`item(kind="lamp")`), red unless its `light` says otherwise. */
+export const lampArt = lightArt("red");
+/** A lantern (`item(kind="lantern")`), yellow unless `light` says otherwise. */
+export const lanternArt = lightArt("yellow");

package/lib/gd/hall/art/marker.d.ts

@@ -0,0 +1,8 @@
+import type { HallArt } from "../types.ts";
+export declare const provenance: import("../types.ts").HallArtProvenance;
+/**
+ * A marker: text in a box or circle, for objects without art yet. The
+ * layout sets the text over it (`HallResolvedObject.inner`), so it counts
+ * against the hall's label lines.
+ */
+export declare const markerArt: HallArt;

package/lib/gd/hall/art/marker.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { enumAttr } from "../attributes.js";
+import { original, PALETTE, variantOf } from "./shared.js";
+export const provenance = original("A labelled box or circle, as the book marks objects and the candidate.");
+const isCircle = (node) => enumAttr(node, "shape", ["box", "circle"]) === "circle";
+function Marker({ node }) {
+    return isCircle(node) ? (_jsx("circle", { r: 48, fill: PALETTE.paper, stroke: PALETTE.ink, strokeWidth: 3 })) : (_jsx("rect", { x: -48, y: -48, width: 96, height: 96, fill: PALETTE.paper, stroke: PALETTE.ink, strokeWidth: 3 }));
+}
+/**
+ * A marker: text in a box or circle, for objects without art yet. The
+ * layout sets the text over it (`HallResolvedObject.inner`), so it counts
+ * against the hall's label lines.
+ */
+export const markerArt = {
+    Component: Marker,
+    box: { width: 100, height: 100 },
+    variant: (node) => variantOf(isCircle(node)),
+    provenance,
+};

package/lib/gd/hall/art/pantacle.d.ts

@@ -0,0 +1,10 @@
+import type { HallArt } from "../types.ts";
+export declare const provenance: {
+    origin: "original" | "thirdParty";
+    author: string;
+    license: string;
+    source?: string;
+    notes?: string;
+};
+/** The Theoricus' Pantacle (`item(kind="pantacle")`), 100 × 100. */
+export declare const pantacleArt: HallArt;

package/lib/gd/hall/art/pantacle.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { svgCoordinate } from "../../../svgCoordinate.js";
+import { GD_HALL_FONT_STACKS } from "../fonts.js";
+import { hebrewFont, labelFont } from "../labels.js";
+import { points } from "./geometry.js";
+import { original, PALETTE, sameForEveryNode } from "./shared.js";
+export const provenance = {
+    ...original("The Pantacle drawn from geometry after Gadi Cohen's own Theoricus " +
+        "badge design: the Earth disc in its four " +
+        "colours, an interlaced hexagram and a ring naming the Earth's " +
+        "correspondences. The names are set letter by letter in the hall fonts " +
+        "(SIL OFL 1.1); no glyph outlines are copied into the code."),
+};
+/** Radii in the 100-unit box. */
+const OUTER = 49;
+const DISC = 40.5;
+/** Where the ring's text stands. */
+const BASELINE = 42.6;
+/** The hexagram's centre line and band. */
+const STAR = 32;
+const BAND = 5;
+const EDGE = 1.4;
+/** The Earth's colours, quartered as in the drawing: citrine above. */
+const QUARTERS = [
+    { angle: -90, fill: PALETTE.citrine }, // East (up)
+    { angle: 0, fill: PALETTE.olive },
+    { angle: 90, fill: PALETTE.earthBlack },
+    { angle: 180, fill: PALETTE.russet },
+];
+/**
+ * The ring: "SAPERE AUDE" at the top, then the Earth's names in the
+ * order the drawing gives them (its "אאאאדני" read as אדני), each in an
+ * eighth of the ring, reading on in the Hebrew direction (anticlockwise).
+ */
+const RING = [
+    { text: "SAPERE AUDE", hebrew: false },
+    ...["אדני", "אוריאל", "כרוב", "פרת", "צפון", "פורלאך", "ארץ"].map((text) => ({
+        text,
+        hebrew: true,
+    })),
+];
+/** Sizes of the ring's letters, in units. */
+const LATIN_SIZE = 5;
+const HEBREW_SIZE = 6.4;
+/**
+ * Where each letter of a name stands, its baseline on the ring and its top
+ * outward. Measured in logical order with the font's advances and kern
+ * pairs; Latin runs clockwise and Hebrew anticlockwise, so both read on
+ * from the name before. Each letter is drawn alone, so no renderer's bidi
+ * or text-on-path support (resvg reverses Hebrew on a path; rsvg draws no
+ * `textPath`) changes the order.
+ */
+function ringGlyphs(text, center, font, size, rightToLeft) {
+    const chars = [...text];
+    const total = font.width(text, size);
+    return chars.flatMap((char, index) => {
+        if (char === " ")
+            return [];
+        // The letter's centre, from the start of the name in reading order.
+        const along = font.width(chars.slice(0, index + 1).join(""), size) -
+            font.width(char, size) / 2;
+        const fromMiddle = along - total / 2;
+        const radians = (rightToLeft ? -fromMiddle : fromMiddle) / BASELINE;
+        return [{ char, angle: center + (radians * 180) / Math.PI }];
+    });
+}
+/** The ring's names, each centred in its eighth, anticlockwise from the top. */
+const RING_GLYPHS = RING.map((name, index) => ({
+    ...name,
+    glyphs: ringGlyphs(name.text, 270 - (index * 360) / RING.length, name.hebrew ? hebrewFont : labelFont, name.hebrew ? HEBREW_SIZE : LATIN_SIZE, name.hebrew),
+}));
+const at = (angle, r) => {
+    const radians = (angle * Math.PI) / 180;
+    return [
+        svgCoordinate(r * Math.cos(radians)),
+        svgCoordinate(r * Math.sin(radians)),
+    ];
+};
+const wedge = (angle) => {
+    const [x0, y0] = at(angle - 45, DISC);
+    const [x1, y1] = at(angle + 45, DISC);
+    return `M0,0L${x0},${y0}A${DISC},${DISC} 0 0 1 ${x1},${y1}Z`;
+};
+const UP = [-90, 30, 150].map((angle) => at(angle, STAR));
+const DOWN = [90, 210, 330].map((angle) => at(angle, STAR));
+/**
+ * Where the down triangle passes over the up one: three of the six
+ * crossings, alternating, as short pieces of its edges redrawn on top. The
+ * white piece runs a little past the black one, so no seam shows where the
+ * piece ends on the band it continues.
+ */
+const OVER = [0, 120, 240].map((angle) => {
+    const [x, y] = at(angle, STAR / Math.sqrt(3));
+    // The down triangle's edge through this crossing runs at angle + 120°.
+    const segment = (half) => {
+        const [dx, dy] = at(angle + 120, half);
+        return points([
+            [x - dx, y - dy],
+            [x + dx, y + dy],
+        ]);
+    };
+    // Long enough to cross the other band (half its width over sin 60°, plus
+    // its slant), short of the next crossing a third of the edge away.
+    const black = 1.1 * (BAND + 2 * EDGE);
+    return { black: segment(black), white: segment(black + 1) };
+});
+function Band({ pointsList }) {
+    return (_jsxs(_Fragment, { children: [_jsx("polygon", { points: pointsList, fill: "none", stroke: PALETTE.ink, strokeWidth: BAND + 2 * EDGE, strokeLinejoin: "miter" }), _jsx("polygon", { points: pointsList, fill: "none", stroke: PALETTE.paper, strokeWidth: BAND, strokeLinejoin: "miter" })] }));
+}
+function Pantacle() {
+    return (_jsxs(_Fragment, { children: [_jsx("circle", { r: OUTER, fill: PALETTE.paper, stroke: PALETTE.ink, strokeWidth: 1.2 }), QUARTERS.map((quarter) => (_jsx("path", { d: wedge(quarter.angle), fill: quarter.fill }, quarter.angle))), _jsx("circle", { r: DISC, fill: "none", stroke: PALETTE.ink, strokeWidth: 0.8 }), _jsx(Band, { pointsList: points(DOWN) }), _jsx(Band, { pointsList: points(UP) }), OVER.map((segment) => (_jsxs("g", { children: [_jsx("polyline", { points: segment.black, stroke: PALETTE.ink, strokeWidth: BAND + 2 * EDGE }), _jsx("polyline", { points: segment.white, stroke: PALETTE.paper, strokeWidth: BAND })] }, segment.black))), RING_GLYPHS.map((name) => (_jsx("g", { fontFamily: name.hebrew ? GD_HALL_FONT_STACKS.hebrew : GD_HALL_FONT_STACKS.serif, fontStyle: name.hebrew ? undefined : "italic", fontWeight: name.hebrew ? 700 : undefined, fontSize: name.hebrew ? HEBREW_SIZE : LATIN_SIZE, fill: PALETTE.ink, textAnchor: "middle", children: name.glyphs.map((glyph) => (_jsx("text", { y: -BASELINE, transform: `rotate(${svgCoordinate((glyph.angle + 450) % 360)})`, children: glyph.char }, glyph.angle))) }, name.text)))] }));
+}
+/** The Theoricus' Pantacle (`item(kind="pantacle")`), 100 × 100. */
+export const pantacleArt = {
+    Component: Pantacle,
+    box: { width: 100, height: 100 },
+    variant: sameForEveryNode,
+    provenance,
+};

package/lib/gd/hall/art/pillar.d.ts

@@ -0,0 +1,4 @@
+import type { HallArt } from "../types.ts";
+export declare const provenance: import("../types.ts").HallArtProvenance;
+/** A pillar: black (downward triangle) or white (upward), in 2 × 2 squares. */
+export declare const pillarArt: HallArt;

package/lib/gd/hall/art/pillar.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { booleanAttr, enumAttr } from "../attributes.js";
+import { triangle } from "./geometry.js";
+import { original, PALETTE, variantOf } from "./shared.js";
+export const provenance = original("Redrawn from geometry after Gadi Cohen's hall drawings: a disc with a " +
+    "downward (black) or upward (white) triangle; glow adds the Neophyte " +
+    "drawing's red radial light inside a grey-rimmed triangle.");
+const isBlack = (node) => enumAttr(node, "kind", ["black", "white"]) !== "white";
+const glows = (node) => booleanAttr(node, "glow") === true;
+function Pillar({ node, defId }) {
+    const black = isBlack(node);
+    const dir = black ? "down" : "up";
+    if (glows(node)) {
+        const glow = defId("glow");
+        return (_jsxs(_Fragment, { children: [_jsx("defs", { children: _jsxs("radialGradient", { id: glow, cx: 0, cy: 0, r: 40, gradientUnits: "userSpaceOnUse", children: [_jsx("stop", { offset: 0, stopColor: PALETTE.glow }), _jsx("stop", { offset: 1, stopColor: PALETTE.glow, stopOpacity: 0 })] }) }), _jsx("circle", { r: 48.8, fill: black ? PALETTE.ink : PALETTE.paper, stroke: PALETTE.rim, strokeWidth: 2.4 }), _jsx("polygon", { points: triangle(44, dir), fill: `url(#${glow})`, stroke: PALETTE.rim, strokeWidth: 5, strokeLinejoin: "miter" })] }));
+    }
+    return (_jsxs(_Fragment, { children: [_jsx("circle", { r: black ? 50 : 48.5, fill: black ? PALETTE.ink : PALETTE.paper, stroke: black ? "none" : PALETTE.ink, strokeWidth: 3 }), _jsx("polygon", { points: triangle(38, dir), fill: black ? PALETTE.paper : PALETTE.ink })] }));
+}
+/** A pillar: black (downward triangle) or white (upward), in 2 × 2 squares. */
+export const pillarArt = {
+    Component: Pillar,
+    box: { width: 100, height: 100 },
+    variant: (node) => variantOf(isBlack(node), glows(node)),
+    provenance,
+};

package/lib/gd/hall/art/placeholder.d.ts

@@ -0,0 +1,8 @@
+export declare const provenance: import("../types.ts").HallArtProvenance;
+/**
+ * What the renderer draws for a tag or item kind without art, in the
+ * placeholder's 100 × 100 box. The name is untrusted and only ever text.
+ */
+export declare function Placeholder({ name }: {
+    name: string;
+}): import("react").JSX.Element;

package/lib/gd/hall/art/placeholder.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { GD_HALL_FONT_STACKS } from "../fonts.js";
+import { wrapText } from "../labels.js";
+import { original, PALETTE } from "./shared.js";
+export const provenance = original("A dashed box naming a component that has no art.");
+/**
+ * What the renderer draws for a tag or item kind without art, in the
+ * placeholder's 100 × 100 box. The name is untrusted and only ever text.
+ */
+export function Placeholder({ name }) {
+    const lines = wrapText(name, 88, 16).slice(0, 3);
+    return (_jsxs(_Fragment, { children: [_jsx("rect", { x: -48, y: -48, width: 96, height: 96, fill: PALETTE.paper, fillOpacity: 0.7, stroke: PALETTE.placeholder, strokeWidth: 2, strokeDasharray: "6 4" }), lines
+                .map((line, index) => ({
+                ...line,
+                y: 6 - ((lines.length - 1) * 19) / 2 + index * 19,
+            }))
+                .map((line) => (_jsx("text", { x: 0, y: line.y, fontSize: 16, fontFamily: GD_HALL_FONT_STACKS.serif, fontStyle: "italic", textAnchor: "middle", fill: PALETTE.placeholder, children: line.text }, line.y)))] }));
+}

package/lib/gd/hall/art/platform.d.ts

@@ -0,0 +1,13 @@
+import type { HallArt, HallArtProps, HallNode } from "../types.ts";
+export declare const provenance: import("../types.ts").HallArtProvenance;
+/** A box `w` × `h` squares, `width` × `height` unless they say otherwise. */
+export declare const sized: (width: number, height: number) => (node: HallNode) => {
+    width: number;
+    height: number;
+};
+/** The white rectangle every platform, throne and board draws. */
+export declare function Platform({ box }: Pick<HallArtProps, "box">): import("react").JSX.Element;
+/** A raised platform (4 × 3 squares unless w and h say otherwise). */
+export declare const platformArt: HallArt;
+/** A throne (2 × 2 squares unless w and h say otherwise). */
+export declare const throneArt: HallArt;

package/lib/gd/hall/art/platform.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { clamp, numberAttr } from "../attributes.js";
+import { SIZE_RANGE } from "../vocabulary.js";
+import { original, PALETTE, sameForEveryNode } from "./shared.js";
+export const provenance = original("A white rectangle with a black outline, sized in squares by w and h.");
+/** Outline width, in squares. */
+const STROKE = 0.06;
+/** A box `w` × `h` squares, `width` × `height` unless they say otherwise. */
+export const sized = (width, height) => (node) => ({
+    width: clamp(numberAttr(node, "w") ?? width, ...SIZE_RANGE),
+    height: clamp(numberAttr(node, "h") ?? height, ...SIZE_RANGE),
+});
+/** The white rectangle every platform, throne and board draws. */
+export function Platform({ box }) {
+    return (_jsx("rect", { x: -box.width / 2, y: -box.height / 2, width: box.width, height: box.height, fill: PALETTE.paper, stroke: PALETTE.ink, strokeWidth: STROKE }));
+}
+const art = (width, height) => ({
+    Component: Platform,
+    box: sized(width, height),
+    fit: "squares",
+    // The box (w × h) is all it draws, and the box is part of the key.
+    variant: sameForEveryNode,
+    provenance,
+});
+/** A raised platform (4 × 3 squares unless w and h say otherwise). */
+export const platformArt = art(4, 3);
+/** A throne (2 × 2 squares unless w and h say otherwise). */
+export const throneArt = art(2, 2);

package/lib/gd/hall/art/seals.d.ts

@@ -0,0 +1,23 @@
+import type { HallPlanet } from "../planets.ts";
+/**
+ * The planets' seals, drawn after the woodcuts of Agrippa's *De occulta
+ * philosophia* (Cologne: Soter, 1533), book II, chapter 22, which gives
+ * each planet's table with its seal ("signacula sive characteres"). Read
+ * from the Library of Congress copy on archive.org,
+ * `DeOccultaPhilosophiaLoc1533`: Venus on p. CLI (leaf n166), the Moon on
+ * p. CLIII (leaf n168). The geometry follows the woodcuts, made clean and
+ * symmetric where the cutter's hand wandered; no image was copied. The
+ * silver plate is our reading of the chapter's text (leaf n162), which
+ * says each of these planets' tables, with its characters, is engraved
+ * on silver; the woodcuts themselves draw the seals on the bare page.
+ * The other five planets keep the placeholder (plan 061, stage H, part
+ * 2).
+ */
+export declare const SEAL_SOURCE: string;
+export declare const SEAL_BASIS: string;
+/** The `seal` art's provenance: these seals, and the placeholder. */
+export declare const sealProvenance: import("../types.ts").HallArtProvenance;
+/** Every art module exports its provenance. */
+export declare const provenance: import("../types.ts").HallArtProvenance;
+/** The seals drawn so far, by planet; the others are a placeholder. */
+export declare const SEALS: ReadonlyMap<HallPlanet, () => React.ReactElement>;

package/lib/gd/hall/art/seals.js

@@ -0,0 +1,151 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { svgCoordinate } from "../../../svgCoordinate.js";
+import { ITEM_DETAIL, ITEM_OUTLINE, PALETTE, publicDomain } from "./shared.js";
+/**
+ * The planets' seals, drawn after the woodcuts of Agrippa's *De occulta
+ * philosophia* (Cologne: Soter, 1533), book II, chapter 22, which gives
+ * each planet's table with its seal ("signacula sive characteres"). Read
+ * from the Library of Congress copy on archive.org,
+ * `DeOccultaPhilosophiaLoc1533`: Venus on p. CLI (leaf n166), the Moon on
+ * p. CLIII (leaf n168). The geometry follows the woodcuts, made clean and
+ * symmetric where the cutter's hand wandered; no image was copied. The
+ * silver plate is our reading of the chapter's text (leaf n162), which
+ * says each of these planets' tables, with its characters, is engraved
+ * on silver; the woodcuts themselves draw the seals on the bare page.
+ * The other five planets keep the placeholder (plan 061, stage H, part
+ * 2).
+ */
+export const SEAL_SOURCE = "Heinrich Cornelius Agrippa, De occulta philosophia libri tres " +
+    "(Cologne: Soter, 1533), book II, chapter 22: Venus p. CLI, the Moon " +
+    "p. CLIII; archive.org DeOccultaPhilosophiaLoc1533 (Library of " +
+    "Congress), leaves n166 and n168.";
+export const SEAL_BASIS = "printed in 1533; Agrippa died in 1535 and the woodcuts' cutters are " +
+    "anonymous, so the work is out of copyright everywhere; a faithful scan " +
+    "of a two-dimensional public-domain work adds no copyright, and the " +
+    "archive.org item carries the Public Domain Mark 1.0. Only the " +
+    "figures' geometry is taken, and no image of the book is committed.";
+/** The `seal` art's provenance: these seals, and the placeholder. */
+export const sealProvenance = publicDomain("A planet's seal drawn from geometry after Agrippa's woodcut, on a " +
+    "silver plate: the Moon's and Venus' so far (plan 061, stage H, part " +
+    "2); for the other planets a placeholder, a dashed ring naming the " +
+    "planet.", { source: SEAL_SOURCE, basis: SEAL_BASIS });
+/** Every art module exports its provenance. */
+export const provenance = sealProvenance;
+/** The engraved lines' width, in the 100-unit box. */
+const LINE = 3;
+/** The small rings at the lines' ends. */
+const RING = 3;
+const n = svgCoordinate;
+const pair = ([x, y]) => `${n(x)},${n(y)}`;
+/** A quadratic through `from`, `via` (at its middle) and `to`. */
+const through = (from, via, to) => {
+    const control = [
+        2 * via[0] - (from[0] + to[0]) / 2,
+        2 * via[1] - (from[1] + to[1]) / 2,
+    ];
+    return `M${pair(from)}Q${pair(control)} ${pair(to)}`;
+};
+/**
+ * A line from the centre ring out to `to`, from the ring's edge; with
+ * `ringed`, it stops at the edge of a ring at `to` too.
+ */
+const spoke = (to, ringed = true) => {
+    const length = Math.hypot(to[0], to[1]);
+    const along = (r) => [
+        (to[0] * r) / length,
+        (to[1] * r) / length,
+    ];
+    return `M${pair(along(RING))}L${pair(ringed ? along(length - RING) : to)}`;
+};
+/**
+ * A circular arc to `to` from `from`, bowed `depth` from its chord: to the
+ * right of the way (as the screen shows it), or with `left`, to the left.
+ */
+const bow = (from, to, depth, left = false) => {
+    const half = Math.hypot(to[0] - from[0], to[1] - from[1]) / 2;
+    const r = (half * half + depth * depth) / (2 * depth);
+    return `A${n(r)},${n(r)} 0 0 ${left ? 1 : 0} ${pair(to)}`;
+};
+/** A point turned a quarter turn clockwise about the centre, `k` times. */
+const turn = ([x, y], k) => k % 4 === 0 ? [x, y] : turn([-y, x], k - 1);
+/**
+ * The Moon's seal: a saltire from a ring at the centre to rings in the
+ * corners, and four crescents between its arms, each a lune with a line
+ * along its middle, rings at its horns.
+ */
+const MOON_CORNER = 38;
+const MOON_HORN = [23, -38];
+/** How deep each crescent's outer, middle and inner arcs bow. */
+const MOON_CRESCENT = [19, 14.5, 10];
+const MOON = (() => {
+    const corners = [0, 1, 2, 3].map((k) => turn([MOON_CORNER, MOON_CORNER], k));
+    const lines = corners.map((corner) => spoke(corner));
+    const crescents = [0, 1, 2, 3].map((k) => {
+        const left = turn([-MOON_HORN[0], MOON_HORN[1]], k);
+        const right = turn(MOON_HORN, k);
+        const [outer, middle, inner] = MOON_CRESCENT;
+        const lune = `M${pair(left)}${bow(left, right, outer)}${bow(right, left, inner, true)}Z`;
+        return { lune, middle: `M${pair(left)}${bow(left, right, middle)}` };
+    });
+    const horns = [0, 1, 2, 3].flatMap((k) => [
+        turn([-MOON_HORN[0], MOON_HORN[1]], k),
+        turn(MOON_HORN, k),
+    ]);
+    return {
+        lines: lines.join(""),
+        lunes: crescents.map(({ lune }) => lune).join(""),
+        middles: crescents.map(({ middle }) => middle).join(""),
+        rings: [[0, 0], ...corners, ...horns],
+    };
+})();
+/**
+ * Venus' seal: three arms of a saltire from a ring at the centre to rings
+ * at their ends; the fourth runs to the foot of a great arc on the right;
+ * above the centre a cross whose stem forks into two arms, serifed at
+ * their ends; an open arc on the left, like a ")"; a ring below. Every
+ * line is engraved at one weight, the left arc as the great one.
+ */
+const VENUS = (() => {
+    const ends = [
+        [-36, -35],
+        [36, -35],
+        [-36, 35],
+    ];
+    const foot = [35, 33];
+    const spokes = [...ends.map((end) => spoke(end)), spoke(foot, false)];
+    const arc = through([30, -21], [40, 6], foot);
+    const leftArc = through([-38, -16], [-27, -3.5], [-38.5, 9]);
+    const cross = "M0,-38V-10.5M-13.5,-27H13.5M0,-27L-11.5,-37.5M0,-27L11.5,-37.5" +
+        "M-2,-38H2M-14,-37.5H-9.5M9.5,-37.5H14";
+    return {
+        lines: spokes.join("") + arc + leftArc + cross,
+        rings: [[0, 0], ...ends],
+        circle: { cx: 0, cy: 25, r: 12.5 },
+    };
+})();
+/** A seal's silver plate, the box's size less the outline. */
+function Plate() {
+    return (_jsx("rect", { x: -47, y: -47, width: 94, height: 94, rx: 8, fill: PALETTE.silver, ...ITEM_OUTLINE }));
+}
+/** The engraving's strokes: the ink, round at the ends. */
+const ENGRAVED = {
+    fill: "none",
+    stroke: PALETTE.ink,
+    strokeWidth: LINE,
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+};
+function Rings({ at }) {
+    return (_jsx("g", { fill: PALETTE.silver, stroke: PALETTE.ink, strokeWidth: ITEM_DETAIL, children: at.map(([x, y]) => (_jsx("circle", { cx: n(x), cy: n(y), r: RING }, `${x},${y}`))) }));
+}
+function MoonSeal() {
+    return (_jsxs(_Fragment, { children: [_jsx(Plate, {}), _jsx("path", { d: MOON.lines, ...ENGRAVED }), _jsx("path", { d: MOON.lunes, ...ENGRAVED, strokeWidth: ITEM_DETAIL }), _jsx("path", { d: MOON.middles, ...ENGRAVED, strokeWidth: 1.6 }), _jsx(Rings, { at: MOON.rings })] }));
+}
+function VenusSeal() {
+    return (_jsxs(_Fragment, { children: [_jsx(Plate, {}), _jsx("path", { d: VENUS.lines, ...ENGRAVED }), _jsx("circle", { ...VENUS.circle, ...ENGRAVED }), _jsx(Rings, { at: VENUS.rings })] }));
+}
+/** The seals drawn so far, by planet; the others are a placeholder. */
+export const SEALS = new Map([
+    ["moon", MoonSeal],
+    ["venus", VenusSeal],
+]);

package/lib/gd/hall/art/shared.d.ts

@@ -0,0 +1,87 @@
+import type { HallArtProvenance } from "../types.ts";
+/** Provenance of art drawn for this package from geometry. */
+export declare function original(notes: string): HallArtProvenance;
+/**
+ * Provenance of art drawn for this package from geometry after a
+ * public-domain original: the drawing (our code and paths) is MIT like
+ * the rest, while the design it follows is in the public domain, on the
+ * recorded `basis`. `source` cites the original by a stable reference.
+ */
+export declare function publicDomain(notes: string, { source, basis }: {
+    source: string;
+    basis: string;
+}): HallArtProvenance;
+/** `HallArt.variant` for art that draws every node alike. */
+export declare const sameForEveryNode: () => string;
+/** `HallArt.variant` from the normalised values a drawing reads. */
+export declare const variantOf: (...values: readonly (string | number | boolean | undefined)[]) => string;
+/** The hall's palette (plan 061, decision 13: light only for now). */
+export declare const PALETTE: {
+    readonly ink: "#000000";
+    readonly paper: "#ffffff";
+    readonly checkerLight: "#f9f9f9";
+    readonly checkerDark: "#ececec";
+    readonly rim: "#cccccc";
+    readonly glow: "#ff0000";
+    readonly bannerDark: "#252524";
+    readonly bannerLightFrom: "#e0e0e0";
+    readonly bannerLightTo: "#ffffff";
+    readonly knob: "#ffe600";
+    readonly tassel: "#d92128";
+    readonly gold: "#fae513";
+    readonly water: "#406ab3";
+    readonly fire: "#d92128";
+    readonly tau: "#f9f9f9";
+    readonly placeholder: "#888888";
+    readonly veil: "#c8b8e0";
+    readonly veilPleat: "#7a64a0";
+    readonly bronze: "#b08d3c";
+    readonly flame: "#ff9a1f";
+    readonly wax: "#fffbe8";
+    /** Gold's deep tone: rims, knops and bands on gold. */
+    readonly goldDeep: "#d4a017";
+    readonly silver: "#d3d7dc";
+    readonly wine: "#7a0c1e";
+    readonly bread: "#e3a857";
+    /** Where a loaf's crust opens. */
+    readonly crumb: "#f6d79a";
+    readonly green: "#108010";
+    readonly rose: "#d92128";
+    /** Air's yellow: the fan. */
+    readonly air: "#ffe000";
+    /** A light's glass, by the colour of its light. */
+    readonly glassRed: "#ff9a8a";
+    readonly glassYellow: "#fbf0b8";
+    readonly glassWhite: "#ffffff";
+    readonly citrine: "#a9aa66";
+    readonly olive: "#444f41";
+    readonly russet: "#8f5642";
+    readonly earthBlack: "#2c2b29";
+    /** The Third Adept's octagram. */
+    readonly orange: "#ff8c1a";
+    /** Typhon's storm cloud (stage H, part 2). */
+    readonly storm: "#6b6f78";
+};
+/**
+ * The items' one outline (plan 061, stage H): black, 3.6 units in a
+ * drawing 100 units on its longer side, round joins. Set on a drawing's
+ * group, so its shapes give only their fills; inner lines are
+ * `ITEM_DETAIL` wide.
+ */
+export declare const ITEM_OUTLINE: {
+    readonly stroke: "#000000";
+    readonly strokeWidth: 3.6;
+    readonly strokeLinejoin: "round";
+    readonly strokeLinecap: "round";
+};
+/** The width of the few lines drawn inside an item's outline. */
+export declare const ITEM_DETAIL = 2.4;
+/**
+ * The one white highlight a metal item carries (direction C's, kept flat):
+ * a stroke along the lit side of the form, drawn over the fill.
+ */
+export declare const HIGHLIGHT: {
+    readonly fill: "none";
+    readonly stroke: "#ffffff";
+    readonly strokeWidth: 2.6;
+};