magick-components
v0.3.1
Published
React components that draw magickal figures from magick-data: the Tree of Life, the Golden Dawn's temple halls, lamens and symbols, the rose-cross sigil, the Enochian tablets, the kameas, the planetary spirits' geomantic sigils and the Moon
Downloads
653
Maintainers
Readme
magick-components
React components that draw magickal figures from
magick-data: the Tree of Life,
the Golden Dawn's temple halls, its lamens and symbols, the rose-cross
sigil, the Enochian tablets, the planetary kameas and the planetary
spirits' geomantic sigils, and the Moon in its phases. They are the drawings of
magick.ly, which consumes this package as anyone else
would. The figures are drawn from the data as inline SVG, so they scale,
print and can be styled by the page around them. A few wrap their drawing
in HTML: the fylfot cross is a table of squares, MoonWidget and
MercuryWidget are tiles around a drawing or a picture, and a planetary
spirit's sigil is
centred in a <div> you may style.
The markup inside a drawing is not part of the API: its elements, ids and attributes may change in any release. What is part of it is each component's props and the classes a component documents as a styling hook (the Tree's layers, below).
It is built and tested in the repository, whose smoke test installs the packed tarball as a stranger would and checks the published shape this README describes.
Licences
Copyright (c) 2020-2026 Gadi Cohen. The package is under three licences, by path, and LICENSE.txt says which file is which:
- The code is MIT, and that includes the drawings. A component whose code is the drawing (the sigils, the lamens, the hall's art, the planetary spirits' sigils) is MIT as code, path data and all, so you may take the drawing from the package under MIT. magick.ly licenses the images it serves under CC BY 4.0, but anyone can render the same drawing from this package under MIT.
- The Moon's paths are also under BSD 3-Clause:
astrology/Moonand the module of its paths adaptphase_junk()from moon-phase, Copyright © 2012, Regents of the University of California. Keep its notice, in LICENSE.txt, with copies of those two modules, including in what you build from them. - The hall's three fonts are under the SIL Open Font License 1.1:
subsets of Noto Serif and Frank Ruhl Libre in
fonts/, with their notices and their sources.
The data the components read is magick-data's, which is licensed by its own files: its code MIT, its data CC BY 4.0, with credit to magick.ly. The app around these components is AGPL-3.0-or-later; this package is deliberately freer, so that it can travel.
A drawing after an old source is our own drawing of a public-domain
printing, cited by page and scan: the planetary spirits' geomantic sigils
(the Rulers of the geomantic figures) follow John Heydon's Theomagia
(1663/4), and the Enochian Watchtowers' plain sigils, and the form of
Air's in colour, the plate of The Equinox (1912). Air's is a Tau with
four Yods above it, drawn as small flames (Regardie, The Golden Dawn,
vol. 4, 1940, p. 307). Regardie says the sigils are taken from Dee's
Sigillum Dei Aemeth (p. 308), whose T carries a 4 above it (The
Equinox I(7), Plate II, archive.org crowley-equinox_202110, leaf
n238), so the four Yods likely stand for that 4; the inference is ours,
not a source's. The form follows Plate X (leaf n256). The coloured Water and
Fire sigils are drawn from Regardie's description of them (1940), and
Earth's is a cross in four colours. Layouts taken from modern books are
facts, drawn in our own art.
Installing
npm install magick-components reactIt needs React 19, and it is ES modules only. @types/react is an optional
peer: TypeScript users have it already. In a Server Component, or anything
that renders React:
import TreeOfLife from "magick-components/kabbalah/TreeOfLife";
export default function Page() {
return <TreeOfLife field="name.he" colorScale="queen" width={300} />;
}Server and Client Components
Most of the components use no hooks, or only useId and useMemo, and
render as Server Components, in plain Node with renderToStaticMarkup, or
in the browser. Three need the browser, and are marked "use client":
astrology/MoonWidget, which works out today's phase after hydration;astrology/MercuryWidget, which works out Mercury's next retrograde;gd/RoseSigil, which optimises and animates the sigil.
A client module's exports all become client references, so each of these
exports only its component. Their helpers live in modules of their own
(astrology/Moon, gd/RoseSigilImage, gd/roseSigilGeometry).
The Moon's drawing alone, astrology/Moon, needs no browser: it draws a
phase you give it, or a date's, which a page that knows the date passes:
import { Moon } from "magick-components/astrology/Moon";
export const Tonight = ({ date }: { date: Date }) => (
<Moon date={date} height={85} hemisphere="south" />
);The entry points
Each is a subpath of the package; there is no root entry. Most subpaths
are one module, and gd/hall gathers the hall's: its exports come from
several modules, and the package declares no side effects but its CSS,
so a bundler takes from it only the modules whose exports a page uses.
Each component is its entry's default export and a named export too
(import TreeOfLife from … or import { TreeOfLife } from …). Each
component imports only the magick-data tables it draws, except
TreeOfLife and GradeTree: a sphere's label may be any field of the
assembled graph, so they import magick-data's root entry, every table.
| Subpath | What it is |
| --- | --- |
| kabbalah/TreeOfLife | The Tree of Life, its spheres labelled from any field of magick-data's sephirot, in the Queen or King scale, with the Hermetic or the Hebrew letters on its paths |
| kabbalah/fieldPath | readFieldPath(), which reads a dotted field path (planet.name.en.en, stones.*.name.en) from a row, as the Tree's labels do |
| gd/GradeTree | The Tree as the map of the Golden Dawn's grades |
| gd/hall | GdHall (also the default export), a Golden Dawn temple hall drawn from a hall description, and what a page needs to draw, check or describe one: the description's types, lenient and strict (below), validateHall(), describeHall(), estimateHallAspect(), GdHallSvg and the layout it draws, the default art and the fonts |
| gd/hall/presets | The halls of the grades, Neophyte to Philosophus and the Portal, as descriptions GdHall draws |
| gd/hall/tags | The hall's tags, for writing a hall as JSX in GdHall (import * as Hall, then <Hall.Floor>, <Hall.Pillar> …; below), with defineHallTag() and defineHallItem() for your own art's tags and item kinds, and hallFromTags(), which gives the hall the tags describe as data |
| gd/Lamen | An officer's lamen |
| gd/lamenGrades | Which grades' lamens each officer wears |
| gd/RoseSigil | The rose-cross sigil of a Hebrew text, optimised and drawn on in the browser ("use client") |
| gd/RoseSigilImage | The same sigil with no hooks, for the server, from points you give it |
| gd/roseSigilGeometry | The rose's letters and where a text's letters stand on it, on either version of the rose: ROSE_LETTERS, roseRings(), roseLetters(), letterPoint() and sigilPoints(), with ROSE_VERSIONS and ROSE_VERSION_NOTES |
| gd/roseSigilOptimizer | optimizeSigilPoints(), the layout optimiser (nlopt, compiled to WASM) |
| gd/SevenBranchedCandlestick | The seven-branched candlestick, with its planets, in two versions: The Equinox's figure of 1909 (the default) and the modern arrangement (CANDLESTICK_VERSIONS, CANDLESTICK_VERSION_NOTES) |
| gd/TableOfShewbread | The table of shewbread, with the signs and the tribes |
| gd/FylfotCross | The fylfot cross of the signs and elements |
| enochian/Tablet | An Enochian tablet, a Watchtower or the Tablet of Union, in the Golden Dawn's, Dee's or another tradition's letters |
| chakras/Chakras | The seven chakras, in their colours, on the outline of a body |
| astrology/Kamea | A planet's kamea, its magic square |
| astrology/PlanetarySpirit | A planetary spirit's geomantic sigil (the Rulers of the figures) |
| astrology/Moon | The Moon in a phase you give, or a date's, as seen from either hemisphere |
| astrology/MoonWidget | A tile of today's Moon and its phase's name, as seen from the viewer's hemisphere ("use client") |
| astrology/MercuryWidget | A tile of Mercury's current or next retrograde, under a picture of the planet you give it ("use client") |
| astrology/mercuryRetrograde | Mercury's stations and retrogrades, from astronomy-engine |
| fonts/* | The hall's fonts and gd-hall.css (below) |
Not stable
| Subpath | What it is |
| --- | --- |
| gd/hall/editor | The toolkit of magick.ly's hall editor: the hall vocabulary, the attribute readers and the layout's measures that the editor reads beyond gd/hall. It serves that editor and may change in any release, a patch included |
The Tree on your page
Without props, TreeOfLife draws as magick.ly's Tree page does by
default: each sphere's Roman name (field="name.roman"), numbered above
(topText="index") and named in English below (bottomText="name.en"),
in the Queen scale (colorScale="queen"), with the Hermetic Tree's
letters on its paths (letterAttr="hermetic"), and its labels at 10
(fontSize; another field sizes its own, 32 for index and 20 for
Hebrew). Stating a default draws the same Tree as leaving it out:
import { TreeOfLife } from "magick-components/kabbalah/TreeOfLife";
export const Tree = () => <TreeOfLife width={300} />;activeSephirah draws one sphere and fades the rest (null fades them
all), and activePath does the same for a path; an id the Tree does not
have throws. The spheres and paths are links only where you give them
one (below). The <svg> is well-formed XML, its
links and its labels' curves xlink:href with the prefix declared.
It keeps to itself, so that several can share a page:
- Ids. The
<svg>'s id is theidyou pass (letters, digits,-and_, starting with a letter) or one from React'suseId, and every id inside it begins with that id and a hyphen (tree-sephirot,tree-topTextPath0). The ids are not a styling hook; they may change.useIdis unique within one React render, so Trees that separate renders put on one page (tworenderToStaticMarkupcalls joined) need anideach. - Classes. Its three layers carry classes you may style by, which are
part of its contract (
TREE_LAYER_CLASSES):magick-tree-paths(the paths' outlines),magick-tree-path-letters(their letters) andmagick-tree-sephirot(the spheres and their labels). magick.ly's dark mode re-inks the outlines through them. - Its stylesheet names only its own
<svg>,flipincluded. - Without hooks.
TreeOfLifeSvg, from the same entry, draws the same Tree with no hooks and needs itsid: forrenderToStaticMarkupin a route handler, where React's server build has no dispatcher foruseId. - Fonts. It sets its labels in Noto Sans and Noto Sans Hebrew (both
OFL), falling back to Arial and sans-serif, and loads nothing itself:
load the two families on your page, or serve
NotoSans-Regular.ttfandNotoSansHebrew-Regular.ttfand pass where they are asfontBaseUrl(<TreeOfLife fontBaseUrl="/fonts" />). The SVG then carries@font-facerules for them, which an exported SVG needs; like any@font-face, they define the two families for the whole page.
A hall on your page
GdHall draws a Golden Dawn temple hall from its description: a tree of
nodes, {type, …attributes, children}, as the presets are.
import { GdHall } from "magick-components/gd/hall";
import { neophyte } from "magick-components/gd/hall/presets";
export const Neophyte = () => <GdHall hall={neophyte.hall} />;GdHall and validateHall() take a HallNode, which is lenient: a
hall a ritual stores may hold anything, and draws what it can. To write
a hall in code, type it with the strict node types, one per tag
(GdHallNode, FloorNode, OfficerNode …), as the presets are typed.
TypeScript then checks much of what the validator checks: which tag may
stand where, the values each attribute takes, and the values a tag needs
(an officer's role, an item's kind, a caption's text, a door's
place along its wall). It leaves the rest to the validator: ranges,
numbers that are not finite (NaN, Infinity), whole numbers where
one is needed (a tarot key's n), letter names (an empty letter
included), the length of text, and the hall's bounds (24 deep, 4000
nodes). They are type aliases, so any strict node is a HallNode:
import { GdHall, type GdHallNode } from "magick-components/gd/hall";
const hall: GdHallNode = {
type: "gdHall",
children: [
{
type: "floor",
children: [
{ type: "pillar", kind: "black", x: 4, y: 3 },
{ type: "pillar", kind: "white", x: 12, y: 3 },
{
type: "altar",
at: "center",
children: [{ type: "item", kind: "cross", form: "calvary" }],
},
{ type: "officer", role: "hiereus", x: 8, y: 14 },
{ type: "door", side: "north", y: 12 },
],
},
{ type: "caption", text: "A hall" },
],
};
export const Hall = () => <GdHall hall={hall} />;The floor is 16 squares each way, x running North to South and y
East to West, with the dais beyond its East edge. The strict types
offer only the vocabulary's spellings, center and gray, which
stored halls may also write centre and grey. An item takes only its
kind's attributes (form on a cross, light on a lamp or a lantern);
as anywhere in TypeScript, only an object literal is checked for one it
does not take. A hall that uses a tag or an item kind your own art adds
is a HallNode.
validateHall() checks any hall, typed or stored, and returns what it
finds; it never throws. Give it the art you draw with: without it, what
the art adds is unknown to it: the tags (tarotKey, tablet, kamea
…), the item kinds pantacle and lightning, a light's light, an
officer's grade and a tablet's element, version, reversed and
alt.
import { DEFAULT_HALL_ART, validateHall } from "magick-components/gd/hall";
import { neophyte } from "magick-components/gd/hall/presets";
export const diagnostics = validateHall(neophyte.hall, {
art: DEFAULT_HALL_ART,
});A hall written as tags
The same halls can be written as JSX, with the tags of
gd/hall/tags, one per tag of the description, as GdHall's children.
The hall's own attributes (wall, dais, compass, padding,
labelSize and the margins) are then GdHall's props. A GdHall
takes hall or tags, never both. The Neophyte preset, written so:
import { GdHall } from "magick-components/gd/hall";
import * as Hall from "magick-components/gd/hall/tags";
const DAIS = [
"imperator",
"cancellarius",
"hierophant",
"pastHierophant",
"praemonstrator",
] as const;
export const Neophyte = () => (
<GdHall wall="gradient">
<Hall.Dais>
{DAIS.map((role) => (
<Hall.Officer key={role} role={role} />
))}
</Hall.Dais>
<Hall.Floor>
<Hall.Banner kind="east" x={9.57} y={-0.06} />
<Hall.Pillar kind="black" x={4} y={3} glow />
<Hall.Officer role="hegemon" x={8} y={3} labelPos="top" />
<Hall.Pillar kind="white" x={12} y={3} glow />
<Hall.Altar at="center">
<Hall.Item kind="cross" y={-0.36} />
<Hall.Item kind="triangle" y={0.24} />
<Hall.Item kind="rose" at="east" x={0.08} />
<Hall.Item kind="salt" at="north" y={-0.3} />
<Hall.Item kind="bread" at="north" x={0.05} y={0.34} />
<Hall.Item kind="lamp" at="south" />
<Hall.Item kind="cup" at="west" y={0.1} />
</Hall.Altar>
<Hall.Officer role="stolistes" x={1.05} y={8} labelPos="bottom" />
<Hall.Officer role="dadouchos" x={14.75} y={8} labelPos="bottom" />
<Hall.Platform x={8} y={14.5} w={4} h={3}>
<Hall.Officer role="hiereus" labelPos="top" />
</Hall.Platform>
<Hall.Banner kind="west" x={4.8} y={14.3} />
<Hall.Officer role="keryx" x={14} y={15} labelPos="top" />
<Hall.Door x={14} width={2} />
<Hall.Officer role="sentinel" x={14} y={17.15} labelPos="bottom" />
</Hall.Floor>
<Hall.Caption text="Neophyte Temple" />
</GdHall>
);GdHall reads the tags; they render nothing themselves. The rules:
- Tags and Fragments only. A component of your own inside a hall is
not drawn:
GdHallcannot see what it would render. Write a shared piece as a function and call it in braces,{pillars()}.null,undefinedand booleans are skipped, so{grade > 0 && <Hall.Veil />}and.map()work; text is a prop (text), and text or numbers as children do not compile. - The props are typed, the nesting is not. Each tag takes its
node's attributes, as strictly as the strict node types do, but JSX
gives every element one type, so TypeScript cannot tell an altar on
the dais from one on the floor:
validateHall()does. For the same reason a hall built from tags is aHallNode. - Build the hall where
GdHallruns. Tags passed through a client component's props arrive asnull, and the hall draws empty. A Server Component that hands a hall to a client component hands it the data,hallFromTags(<GdHall …>…</GdHall>).hall, which takes the root's attributes from thatGdHalland ignores what only draws (width,className…). Itsdiagnosticslist what it dropped: a dropped child has no node, so each names its parent'spathand, aschild, its place among the parent's children as written. - Warnings are for development. When
process.env.NODE_ENVis notproduction,GdHallwarns about each child it dropped, about tags that gave no hall at all, and abouthallgiven with children or with root attributes, which it ignores; a tag warns when React renders it, outside aGdHallor across a client boundary. Whereprocess.env.NODE_ENVcannot be read at all, as on a page loaded without a bundler, they stay silent. From a Server Component the warnings appear in the server's terminal, not the browser's console. Each message is given once per process, so a long-running development server repeats none until it restarts. - Keys are optional. React does not ask for keys on tags in an
array, since it never renders them; Biome's
useJsxKeyInIterablestill does. - One error reads oddly. A
GdHallgiven bothhalland children reports thatGdHallNodeis not assignable toundefined: the children chose the tags form, which takes nohall.
Your own art's tags and item kinds get tags of their own, typed by the
props you give them; a hall that uses them is a HallNode:
import { GdHall, type HallNode } from "magick-components/gd/hall";
import * as Hall from "magick-components/gd/hall/tags";
// A node type your art registers as `serpentTree`, and an item kind it
// registers as `item:sistrum`.
const SerpentTree = Hall.defineHallTag<Hall.HallPlaced & { coils?: number }>(
"serpentTree",
);
const Sistrum = Hall.defineHallItem<{ metal?: "gold" | "silver" }>("sistrum");
export const { hall, diagnostics } = Hall.hallFromTags(
<GdHall>
<Hall.Floor>
<SerpentTree coils={3} at="center" />
<Sistrum metal="gold" x={4} y={12} />
</Hall.Floor>
</GdHall>,
);
export const same: HallNode = hall;<Sistrum metal="gold" x={4} y={12} /> is {type: "item", kind:
"sistrum", metal: "gold", x: 4, y: 12}. Besides the tags, Hall.
offers defineHallTag, defineHallItem and hallFromTags.
The hall's fonts
GdHall measures its labels with the three font subsets in fonts/, and
names its own font families so that no other build of Noto Serif or Frank
Ruhl Libre stands in for them. Load them in one of two ways:
Import the stylesheet, and your bundler emits the fonts with the rest of your assets:
import "magick-components/fonts/gd-hall.css";The package's
sideEffectskeeps the import under any bundler. TypeScript 6 checks that a side-effect import names a module it knows of. Next's types, whichnext-env.d.tsbrings in, declare CSS files; elsewhere, a declaration file of your own does:// css.d.ts declare module "*.css";Serve the files yourself and pass where they are as
fontBaseUrl(<GdHall hall={…} fontBaseUrl="/fonts" />); the SVG then carries its own@font-facerules, which an exported SVG needs.
The rose sigil and nlopt
RoseSigil optimises the sigil's layout with
nlopt-js, whose Emscripten glue
asks for Node's fs even in a browser bundle. Both of Next's bundlers then
fail with Can't resolve 'fs' until you stub it out:
// next.config.ts
import type { NextConfig } from "next";
const nextConfig: NextConfig = {
// Turbopack (next dev, and next build since Next 16): empty.ts is an
// empty module of your own.
turbopack: { resolveAlias: { fs: { browser: "./empty.ts" } } },
// webpack (next build --webpack)
webpack: (config, { isServer }) => {
if (!isServer)
config.resolve.fallback = { ...config.resolve.fallback, fs: false };
return config;
},
};
export default nextConfig;Only RoseSigil and gd/roseSigilOptimizer reach nlopt; a page that
draws the sigil on the server with RoseSigilImage, or uses nothing of the
sigil, needs no stub. If the optimiser fails to load, RoseSigil keeps the
letters' centres it first drew. Text that is not Hebrew is left out of the
sigil, and final forms are drawn as their base letters.
The rose has two versions, which differ in where Kaph and Tau stand on its
middle ring: the Golden Dawn's, as The Equinox printed it (gd, the
default), and Regardie's of 1939 (version="regardie1939").
ROSE_VERSION_NOTES, from gd/roseSigilGeometry, names each and says
where it comes from; give sigilPoints() the same version as the drawing.
What you supply
An Enochian font.
Tabletdraws the Latin transliteration unless you passenochianStyle, the CSS of a font that sets the Enochian letters. The one magick.ly uses has no licence text, so it is not in the package.The tiles' pictures.
MoonWidgetandMercuryWidgettake their background asbackground, a URL drawn to cover, andMercuryWidgetthe planet's picture asimage(a URL, or<img>props such as Next'sgetImageProps()gives). Neither draws a picture of its own; without them the tile has no background.The Tree's fonts, Noto Sans and Noto Sans Hebrew, on your page or through
fontBaseUrl(above).Links.
TreeOfLifeandGradeTreelink nothing unless you passsephirahHrefandpathHref. Each is given the sphere's or the path's magick-data row and returns a URL, ornullfor no link; the links are plain SVG links, which the browser follows:import { TreeOfLife } from "magick-components/kabbalah/TreeOfLife"; export const LinkedTree = () => ( <TreeOfLife sephirahHref={(sephirah) => `/sephirot/${sephirah.id}`} pathHref={(path) => `/paths/${path.id}`} /> );Ink, where it is not black. The fylfot cross borders its squares, and a planetary spirit's sigil is drawn, in black unless you pass
ink, a CSS colour such as your theme's custom property (ink="var(--my-ink, black)"), as magick.ly does for the cross in its dark mode. The sigil's path keeps itsstroke="#000"attribute, which your stylesheet may select, and takesinkas its style, which wins.Labels.
labelmeans one thing wherever a drawing takes it (Tablet,Kamea). Not given, the drawing is an image named for what it draws ("Enochian Watchtower of Fire", "Kamea of Saturn"); a string names it otherwise; andlabel={false}marks it decorative, hidden from assistive technology (aria-hidden), as for a drawing inside one that names itself or beside text that says what it is.
Versions
The props are still settling, so the package stays at 0.x: a minor version
may change them, and a patch will not. It depends on magick-data at the
version it was built with (^0.x), and moves with it.
From 0.1.0, each release is published by the repository's CI when the
version changes on main, with npm provenance naming the commit it was
built from, as magick-data's are. CI publishes a pre-release under the
next tag and a release under latest. The first version, the release
candidate 0.1.0-rc.0, was published by hand.
0.2.0 adds the strict hall node types and changes three things, as a 0.x minor may:
HallPreset.hallnarrows fromHallNodetoGdHallNode, which is still aHallNode. Code that reads an attribute off a preset's nodes by name (preset.hall.children?.map((c) => c.x)), or assigns aHallNodetopreset.hall, stops compiling; widen the hall first:const hall: HallNode = preset.hall.- The Neophyte preset's altar is
at="center", no longerat="centre"; the two draw the same. validateHall()reads an attribute orchildrenset toundefinedas absent, as the layout does: it reports fewer problems, never more.
0.3.0 adds the hall tags, gd/hall/tags, and GdHall's tags form.
GdHallProps is as it was, the hall form's props, and GdHall
takes (GdHallProps & { children?: never }) | GdHallTagsProps, where
GdHallRenderProps, the props that only draw, is GdHallProps without
hall. A wrapper that extends, destructures or forwards GdHallProps
still compiles. One that hands GdHall children of its own, which
0.2.0 ignored, no longer does: children now mean tags, so leave them
out of what reaches GdHall.
ComponentProps<typeof GdHall> is now that union, in which hall may
be missing: code that types its props so and destructures hall, reads
it as a HallNode, or leaves a prop out with Omit (which flattens a
union) no longer compiles. Name the form instead: GdHallProps, or
Omit<GdHallProps, …>, for the hall form, and GdHallTagsProps for
tags. In
development, GdHall and the tags warn on the console as above, the
package's first reading of NODE_ENV; in production they stay
silent. That includes <GdHall hall={hall} /> while hall is still
undefined (data loading, say): it draws the empty hall it drew
before, and now warns that it did.
0.3.1 mends three edge cases. hall={null}, which only JavaScript
(or TypeScript without strictNullChecks) can write, counts as no
hall in GdHall and in hallFromTags: GdHall draws its tags with
its root attributes, or warns of an empty hall as it does for
undefined. hallFromTags given a GdHall imported through a
"use client" module says so. And GdHall given hall with root
attributes warns in development that it ignores them: a literal
<GdHall hall={…} wall="plain" /> does not compile, but a wrapper
whose props extend GdHallProps with wall or padding and spread
them into GdHall does, and now hears of it.
Requirements
React 19 and an ES module environment: Node 22 or later (engines
says so), or any current bundler. The declarations name .ts files, as magick-data's do;
TypeScript 6 reads them under bundler and nodenext.
Provenance
Every drawing here is either drawn in code from magick-data's tables or our own drawing after a source, and the table below says which, with the source. The code is MIT and that cannot be taken back, so "Signed off" is the date the owner checked the row's provenance, and no version past 0.0.0 ships while a row has none; a test holds the first column to the package's entries.
| Drawing | Source | Signed off |
| --- | --- | --- |
| The planetary spirits' sigils (astrology/PlanetarySpirit) | Our own drawings of 13 November 2026 after John Heydon, Theomagia, vol. 1 (London, 1663/4), book I, ch. V, pp. 13 and 15 (archive.org theomagiaortempl00heyd, leaves n124 and n126): a few strokes of one width placed by eye over the scan, not traced. They replace tracings of a 1994 printing in copyright, which the repository's history keeps and the package does not | 2026-11-14 |
| The Enochian tablets' letters (enochian/Tablet) | magick-data's enochian/tablets.json5, in each tradition's reading, signed off in its Sources; the tablet draws them as text | 2026-11-14 |
| The Watchtowers' sigils (enochian/Tablet) | Drawn in code from lines, arcs and curves. The plain sigils, and the form of Air's in colour, after The Equinox I(7) (1912), Plate X (archive.org crowley-equinox_202110, "The Equinox Vol. 1, No. 7", leaf n256); the coloured Water and Fire sigils from Regardie's description, The Golden Dawn, vol. 4 (1940); Earth's a cross in four colours | 2026-11-14 |
| The Air sigil's four Yods (enochian/Tablet) | Regardie, The Golden Dawn, vol. 4 (1940), p. 307 (archive.org IsraelRegardie-TheGoldenDawn-Vol4-1940, leaf n299) describes a Tau with four Yods above it; drawn as small flames after Plate X (above), hand-placed curves in code, not traced. That the Yods stand for the 4 over the T of Dee's Sigillum Dei Aemeth (The Equinox I(7), Plate II, leaf n238) is our inference, not a source's. They replace two fonts' glyphs, which the repository's history keeps | 2026-11-14 |
| The kameas (astrology/Kamea) | A grid drawn in code around magick-data's squares (magick-data/astrology/kameas), which are Agrippa's, De occulta philosophia (Cologne, 1533), book II, ch. 22, pp. CXLIX–CLIII (archive.org DeOccultaPhilosophiaLoc1533, leaves n164–n168), checked cell by cell; where the 1533 printing repeats a number (Venus, row 4: 45 for 43, which its Hebrew table gives; the Moon, row 1: 45 for 54) the square has the number that makes it magic | 2026-11-14 |
| The rose-cross sigil (gd/RoseSigil, gd/RoseSigilImage, gd/roseSigilGeometry, gd/roseSigilOptimizer) | Drawn in code. The rose's construction, three rings of letters at equal angles, is Gadi Cohen's original geometry, written out in gd/roseSigilGeometry, and the sigil's path is laid out by the optimiser over it. The order of the letters is in two versions. The Golden Dawn's (gd, the default) is the figure Crowley printed in The Equinox I(3) (1910), Diagram 63, plate facing p. 210 (archive.org crowley-equinox_202110, "The Equinox Vol. 1, No. 3", leaf n220), and the colour key to the rose in "The Complete Symbol of the Tarot", The Equinox I(8) (1912), plate facing p. 145 (the same item, "The Equinox Vol. 1, No. 8", leaf n174). Regardie's (regardie1939), which exchanges Kaph and Tau, is The Golden Dawn, vol. 3 (Aries Press, Chicago, 1939), p. 53 and Diagram 20, p. 56 (archive.org IsraelRegardie-TheGoldenDawn-Vol3-1939, leaves n46 and n49) | 2026-11-14 |
| The temple halls' art (gd/hall, gd/hall/presets, gd/hall/tags, gd/hall/editor) | Our own art, in code. The halls' layouts are facts from Regardie, The Golden Dawn, vol. 2 (Aries Press, Chicago, 1938), cited for each hall by page and archive.org leaf (IsraelRegardie-TheGoldenDawn-Vol2-1938); no drawing of his is copied. Venus' and the Moon's seals follow Agrippa's woodcuts (1533), book II, ch. 22, pp. CLI and CLIII (archive.org DeOccultaPhilosophiaLoc1533, leaves n166 and n168), their geometry only. Each art records its source in its provenance | 2026-11-14 |
| The halls' fonts (fonts/*) | Subsets of Noto Serif and Frank Ruhl Libre under the SIL Open Font License 1.1, made from google/fonts at a pinned commit; fonts/SOURCES.md gives the files, their hashes and how they are made | 2026-11-14 |
| The Moon (astrology/Moon, astrology/MoonWidget) | The paths of the lit part and the disc adapt phase_junk() from moon-phase, Copyright © 2012 Regents of the University of California, under the BSD 3-Clause License, at a pinned commit (see Licences); the phase comes from lune (Apache-2.0, a dependency). The tile draws no picture of its own | 2026-11-14 |
| Mercury's retrogrades (astrology/MercuryWidget, astrology/mercuryRetrograde) | Our code, MIT, computing the stations with astronomy-engine (MIT, a dependency). The tile draws no picture of its own: the planet's is the page's | 2026-11-14 |
| The Tree of Life and the Grade Tree (kabbalah/TreeOfLife, kabbalah/fieldPath, gd/GradeTree) | Drawn in code, original geometry: four equal circles through each other's centres (Kether, Daath, Tiphareth, Yesod), the side spheres at their crossings. Its proportions agree with the Order's own Tree, "The Minutum Mundum", in Regardie, The Golden Dawn, vol. 1 (Aries Press, Chicago, 1937), plate facing p. 191 (archive.org IsraelRegardie-thegoldenDawn-vol1-1937, leaf n182), and the six spheres round Tiphareth are the hexagram of vol. 2 (1938), p. 195 (archive.org IsraelRegardie-TheGoldenDawn-Vol2-1938, leaf n188). The arrangement of spheres and paths is Kircher's, Oedipus Aegyptiacus II.1 (1653) (Wikimedia Commons, File:Tree of Life (Kircher 1653).jpg). We found no source describing the circle construction itself. Labels and colours come from magick-data's sephirot and paths | 2026-11-14 |
| The lamens (gd/Lamen, gd/lamenGrades) | Drawn in code from geometry, nothing traced. The officers' lamens and their colours are facts from Regardie, The Golden Dawn, vol. 3 (Aries Press, 1939), pp. 82–84 and 88–96 (archive.org IsraelRegardie-TheGoldenDawn-Vol3-1939, leaves n74–n76 and n80–n88); the Stolistes' cup follows the Cup of Stolistes, vol. 1 (1937), p. 138 (IsraelRegardie-thegoldenDawn-vol1-1937, leaf n128); the Portal's lamens are from vol. 2 (1938), p. 156 (leaf n149). The rings' colours, the Keryx's caduceus and the Sentinel's wedjat are our own; no 1937–40 source gives the Sentinel's design. gd/Lamen's comment cites these pages and the modern works it compared | 2026-11-14 |
| The seven-branched candlestick (gd/SevenBranchedCandlestick) | Drawn in code, our own art; the planets, their letters and the angels' and spheres' names are magick-data's. Two versions. The default (equinox1909) is after The Equinox I(2) (1909), p. 265, Diagram 17 (archive.org crowley-equinox_202110, "The Equinox Vol. 1, No. 2", leaf n266), its lettering not traced; the seven churches of Asia are a table in the component that cites the figure. The modern arrangement (modern) has no public-domain source: Regardie, The Golden Dawn, vol. 2 (Aries Press, Chicago, 1938), p. 62 (archive.org IsraelRegardie-TheGoldenDawn-Vol2-1938, leaf n56) describes the lamps but not which planet stands where, and the order is a fact from the 2015 Llewellyn edition of Regardie's The Golden Dawn, nothing of which is copied; its angels are Agrippa's planetary angels | 2026-11-14 |
| The table of shewbread (gd/TableOfShewbread) | Drawn in code. The Zelator ritual describes it, Regardie vol. 2 (1938), pp. 60–61 (leaves n54–n55); its form is The Equinox I(2) (1909), p. 265, Diagram 16 (archive.org crowley-equinox_202110, "The Equinox Vol. 1, No. 2", leaf n266); the Kerubim and signs are placed by the elements' quarters, East at the top; the archangels' names, the permutations of the Name and the tribes are magick-data's, the last two after Crowley's 777 (1909), cols. CXL–CXLI | 2026-11-14 |
| The fylfot cross (gd/FylfotCross) | A table of squares in code after the Fylfot Cross of the Third Knowledge Lecture, Regardie, The Golden Dawn, vol. 1 (Aries Press, 1937), p. 131 (archive.org IsraelRegardie-thegoldenDawn-vol1-1937, leaf n122), which the Zelator ritual explains, vol. 2 (1938), p. 57 (leaf n51); the symbols are magick-data's and the arms' colours our own | 2026-11-14 |
| The chakras (chakras/Chakras) | The seated figure is an original drawing of 13 November 2026, hand-placed curves in code, nothing traced or adapted; it replaces a silhouette of unrecorded source, which the repository's history keeps. The chakras' places and colours are magick-data's chakras.json5 | 2026-11-14 |
