@originkit/avatars 0.0.0-stage → 0.1.0

package/GUIDE.md

@@ -0,0 +1,44 @@
+# Using OriginKit Avatars in your project
+
+OriginKit Avatars turns a name into an avatar. The same name and style always give the same SVG, with no network. The styles are listed at the end.
+
+## Pick a surface
+
+- **MCP** (inside an AI app): the `create_avatar` tool returns the SVG. Use it to look at avatars or to write one file. It is not a runtime dependency of your app.
+- **CLI**: `npx @originkit/avatars <style> <name> [-o file.svg]`, and `npx @originkit/avatars --list` for the styles. Use it in scripts and build steps.
+- **npm**: `npm install @originkit/avatars`, then `import { createAvatar, styles } from "@originkit/avatars"`. Use it when your app draws avatars itself. `createAvatar(style, name)` returns an SVG string and throws on an unknown style.
+- **API**: not live yet. It is coming. Don't call or invent endpoints.
+
+## Recipes
+
+React or Next.js. The output is trusted, generated SVG, so a data URI is simplest:
+
+```tsx
+import { createAvatar } from "@originkit/avatars";
+
+const src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(createAvatar("bots", user.id))}`;
+return <img src={src} alt="" width={48} height={48} />;
+```
+
+Use `<img>`, not inline SVG. Each `<img>` is its own document, while inline SVGs of one style share ids and the second one draws wrong.
+
+Plain HTML: write the SVG to a file with the CLI, then `<img src="bobo.svg" alt="">`.
+
+Node script that writes files:
+
+```js
+import { writeFileSync } from "node:fs";
+import { createAvatar } from "@originkit/avatars";
+
+writeFileSync("bobo.svg", createAvatar("bots", "Bobo"));
+```
+
+Seed with something stable, such as a user id or email, so a user keeps their avatar. A display name that can change will change the avatar.
+
+Pick one style for the product from the list at the end of this guide, and use it everywhere. Mixing styles per user is fine too.
+
+## Facts
+
+- Same input, same SVG, within a major version of the package. A change to how avatars look is always a new major version. There is no randomness and no state.
+- Output is SVG only. For PNG, draw the SVG onto a browser canvas.
+- Faces avatars use "Adventurer Neutral" by Lisa Wischofsky, CC BY 4.0. Where Faces are shown, your app must show that credit visibly, with a link to https://creativecommons.org/licenses/by/4.0/. The SVG carries it as a comment, which is not enough on its own.

package/LICENSE

@@ -0,0 +1,58 @@
+MIT License
+
+Copyright (c) 2026 landerdevelopers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-------------------------------------------------------------------------------
+Third-party notices
+-------------------------------------------------------------------------------
+
+The name hashing in traits.ts, the whole of blobs/, and the superellipse in
+bots/paths.ts are adapted from blobatar (https://github.com/Alain00/blobatar),
+used under the MIT License.
+
+The art in faces/adventurer-neutral.json is a remix of "Adventurer Neutral"
+(https://www.figma.com/community/file/1184595184137881796) by Lisa Wischofsky,
+licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/), as
+distributed by DiceBear. Changes: pupils separated and animated, reactions and
+tap effects added. CC BY 4.0 requires this credit to be visible to anyone a
+published version of Faces reaches.
+
+MIT License
+
+Copyright (c) 2026 Alain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,120 @@
-# Temporary Holding Version
+# @originkit/avatars
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+OriginKit Avatars turns any name into an avatar. 18 styles, SVG out, no network. The same name and style always give the same avatar. One package holds the library, the CLI and the MCP server.
+
+Try every style in the studio: https://originkit.dev/avatars
+
+## Library
+
+```sh
+npm install @originkit/avatars
+```
+
+```js
+import { createAvatar, styles } from "@originkit/avatars";
+
+const svg = createAvatar("bots", "user-8f3a2c"); // an SVG string
+styles; // [{ id: "bots", label: "Bots" }, { id: "blobs", label: "Blobs" }, ...]
+```
+
+The package exports two things:
+
+- `createAvatar(style, name)`: returns the avatar as an SVG string. It throws on a style id that doesn't exist, and the error lists the ids.
+- `styles`: every style as `{ id, label }`, in the studio's order.
+
+Seed it with something stable, such as a user id, so each user keeps their avatar. A display name that can change will change the avatar.
+
+In a web page, use an `<img>` with a data URI rather than inline SVG, because inline SVGs of one style share ids:
+
+```jsx
+<img src={`data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`} alt="" width={48} height={48} />
+```
+
+## CLI
+
+Run it with npx, or install it and call `avatars`.
+
+```sh
+npx @originkit/avatars bots Bobo > bobo.svg
+npx @originkit/avatars bots Bobo -o bobo.svg
+npx @originkit/avatars --list
+```
+
+## MCP
+
+`npx -y @originkit/avatars mcp` runs the MCP server over stdio. It is also hosted at `https://originkit.dev/avatars/mcp`.
+
+- `list_styles`: the style ids and labels.
+- `create_avatar`: `style` (an id from `list_styles`) and `name` (1 to 100 characters). Returns the SVG as text, and again as an embedded `image/svg+xml` resource.
+- `usage_guide`: how to add OriginKit Avatars to a project through the CLI, the npm package or MCP. Also served as the resource `avatars://guide`, and the server's instructions point agents to it.
+
+The server doesn't write files. The client saves the SVG where it wants it.
+
+Claude Code:
+
+```sh
+claude mcp add avatars -- npx -y @originkit/avatars mcp
+```
+
+Codex:
+
+```sh
+codex mcp add avatars -- npx -y @originkit/avatars mcp
+```
+
+Claude on the web, ChatGPT and other apps that take a URL: add a custom connector with `https://originkit.dev/avatars/mcp` (no auth).
+
+Cursor, VS Code: one-click buttons on the [docs page](https://www.originkit.dev/docs/avatars).
+
+Claude Desktop and other clients (`claude_desktop_config.json` or similar):
+
+```json
+{
+  "mcpServers": {
+    "avatars": { "command": "npx", "args": ["-y", "@originkit/avatars", "mcp"] }
+  }
+}
+```
+
+## Styles
+
+Pass the id to `createAvatar`, the CLI or the MCP server.
+
+| Style | Id | Look |
+| --- | --- | --- |
+| Bots | `bots` | A robot head with parts bolted on |
+| Blobs | `blobs` | A soft blob with a face |
+| Gummies | `gummies` | A jelly, lit from inside |
+| Mallows | `mallows` | Soft clay: a bun, a ghost or a cloud |
+| Faces | `faces` | An illustrated person (needs a credit, see Licence) |
+| Bubbles | `bubbles` | A soft gradient shape under fine grain, with two eyes |
+| Pixels | `pixels` | A pixel-art person |
+| Glyphs | `glyphs` | A solid silhouette with two eyes, on a rounded tile |
+| Peeks | `peeks` | A creature peering into a bright tile, with big glossy eyes |
+| Doodles | `doodles` | A hand-drawn face showing a feeling |
+| Animals | `animals` | A cat, a dog, an owl, a bear or a tiger |
+| Buddies | `buddies` | A tabby or a calico cat |
+| Shapes | `shapes` | A face put together from bold shapes |
+| Critters | `critters` | A monster, a cyclops, a bear, a duck, a chick, an imp or a grump, up close |
+| Grins | `grins` | A button of a face, a tile or round, with a toothy grin |
+| Knits | `knits` | A bust in a knitted balaclava and a ribbed beanie |
+| Glances | `glances` | Just two eyes |
+| Auras | `auras` | Soft colour melting together under fine grain, or a sky, on a rounded tile |
+
+Bots, Blobs, Gummies and Mallows are drawn in 3D in the studio. The package returns a flat SVG of each. Buddies and Knits are in the package but not shown in the studio for now.
+
+`npx @originkit/avatars --list` prints the same list.
+
+## Stability
+
+Within a major version, the same input always gives the same SVG. Any change to how avatars look is released as a new major version.
+
+## Licence
+
+MIT. The Faces style uses "Adventurer Neutral" by Lisa Wischofsky, CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Show that credit wherever Faces avatars appear. Faces SVGs also carry it as a comment. See LICENSE for third-party notices.
+
+## Test
+
+```sh
+npm test --workspace @originkit/avatars
+```

package/bin/avatars.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { writeFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { createAvatar, styles } from "../dist/index.js";
+
+const HELP = `OriginKit Avatars: turn any name into an avatar.
+
+Usage
+  avatars <style> <name...>            print the SVG
+  avatars <style> <name...> -o a.svg   write it to a file
+  avatars --list                       show the styles
+  avatars mcp                          run the MCP server over stdio
+
+Example
+  npx @originkit/avatars bots Bobo > bobo.svg`;
+
+const fail = (message) => {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+};
+
+// `avatars mcp` hands the process to the MCP server, which owns stdout from here.
+if (process.argv[2] === "mcp") {
+  await import("../mcp/server.js");
+} else {
+  run();
+}
+
+function run() {
+  let args;
+  try {
+    args = parseArgs({
+      allowPositionals: true,
+      options: {
+        out: { type: "string", short: "o" },
+        list: { type: "boolean", short: "l" },
+        help: { type: "boolean", short: "h" },
+      },
+    });
+  } catch (error) {
+    fail(`${error.message}\n\n${HELP}`);
+  }
+
+  const { values, positionals } = args;
+
+  if (values.help) {
+    process.stdout.write(`${HELP}\n`);
+  } else if (values.list) {
+    for (const { id, label } of styles) process.stdout.write(`${id.padEnd(10)}${label}\n`);
+  } else {
+    const [style, ...words] = positionals;
+    const name = words.join(" ").trim();
+    if (!style || !name) fail(HELP);
+
+    let svg;
+    try {
+      svg = createAvatar(style, name);
+    } catch (error) {
+      fail(error.message);
+    }
+
+    if (values.out) writeFileSync(values.out, svg);
+    else process.stdout.write(svg);
+  }
+}

package/dist/art.d.ts

@@ -0,0 +1,43 @@
+/** Draws art from DiceBear style definitions, which describe SVG as JSON. */
+import type { Traits } from "./traits.ts";
+export type Attribute = string | {
+    type: "color";
+    name: string;
+};
+export interface ArtElement {
+    name: string;
+    attributes?: Record<string, Attribute>;
+    children?: ArtElement[];
+}
+export interface Variant {
+    elements: ArtElement[];
+    weight?: number;
+    tags?: string[];
+}
+export interface Component {
+    width: number;
+    height: number;
+    probability?: number;
+    translate?: {
+        x?: {
+            min: number;
+            max: number;
+        };
+        y?: {
+            min: number;
+            max: number;
+        };
+    };
+    variants: Record<string, Variant>;
+}
+/** `idPrefix` keeps ids unique per face, because a hidden face must not own a shared mask. */
+export declare function draw(element: ArtElement, colors: Record<string, string>, idPrefix: string): string;
+/**
+ * Moves the ids that start `stem-` to `ids-`, with every reference to them, so two live
+ * avatars on one page never share one. With `ids` left as the stem, nothing changes.
+ */
+export declare const scopeIds: (markup: string, stem: string, ids: string) => string;
+/** `scopeIds` over every piece of markup in an avatar, lists such as ears included. */
+export declare function scopeAll<T extends object>(avatar: T, stem: string, ids: string): T;
+/** A weighted choice, limited to `names` when given. */
+export declare function pickVariant(t: Traits, key: string, variants: Record<string, Variant>, names?: string[]): string;

package/dist/art.js

@@ -0,0 +1,35 @@
+/** Draws art from DiceBear style definitions, which describe SVG as JSON. */
+/** `idPrefix` keeps ids unique per face, because a hidden face must not own a shared mask. */
+export function draw(element, colors, idPrefix) {
+    const attributes = Object.entries(element.attributes ?? {})
+        .map(([key, raw]) => {
+        const value = typeof raw === "string" ? raw : colors[raw.name];
+        const scoped = key === "id" ? `${idPrefix}${value}` : value.replace("url(#", `url(#${idPrefix}`);
+        return ` ${key}="${scoped}"`;
+    })
+        .join("");
+    const children = (element.children ?? []).map((child) => draw(child, colors, idPrefix)).join("");
+    return `<${element.name}${attributes}>${children}</${element.name}>`;
+}
+/**
+ * Moves the ids that start `stem-` to `ids-`, with every reference to them, so two live
+ * avatars on one page never share one. With `ids` left as the stem, nothing changes.
+ */
+export const scopeIds = (markup, stem, ids) => ids === stem ? markup : markup.replace(new RegExp(`(id="|href="#|url\\(#)${stem}-`, "g"), `$1${ids}-`);
+/** `scopeIds` over every piece of markup in an avatar, lists such as ears included. */
+export function scopeAll(avatar, stem, ids) {
+    if (ids === stem)
+        return avatar;
+    const scope = (value) => typeof value === "string" ? scopeIds(value, stem, ids) : Array.isArray(value) ? value.map(scope) : value;
+    return Object.fromEntries(Object.entries(avatar).map(([key, value]) => [key, scope(value)]));
+}
+/** A weighted choice, limited to `names` when given. */
+export function pickVariant(t, key, variants, names = Object.keys(variants)) {
+    let remaining = t(key) * names.reduce((sum, name) => sum + (variants[name].weight ?? 1), 0);
+    for (const name of names) {
+        remaining -= variants[name].weight ?? 1;
+        if (remaining < 0)
+            return name;
+    }
+    return names[names.length - 1];
+}

package/dist/auras/calming.d.ts

@@ -0,0 +1,18 @@
+/**
+ * What Possibilities calms on an aura or a sky. Low keeps the eight calmest formations and
+ * palettes, one for each variant, and draws the turn, the
+ * softness and where each shape sits towards their middle. The grain's range and how far a
+ * sky's horizon strays grow with it too, in `index.ts`. Indices are plainest first.
+ */
+import type { Calming } from "../possibilities.ts";
+export declare const CALMING: Calming;
+/**
+ * Each type's palettes, plainest first, which Possibilities keeps eight of at the lowest. For
+ * skies, the gentle daytime ones, then dusk, and night last; for auras, the soft pastels, then
+ * the deep.
+ */
+export declare const PALETTE_ORDER: {
+    Sky: number[];
+    Aura: number[];
+};
+export declare const NOTES: [string, string, string];

package/dist/auras/calming.js

@@ -0,0 +1,30 @@
+/**
+ * What Possibilities calms on an aura or a sky. Low keeps the eight calmest formations and
+ * palettes, one for each variant, and draws the turn, the
+ * softness and where each shape sits towards their middle. The grain's range and how far a
+ * sky's horizon strays grow with it too, in `index.ts`. Indices are plainest first.
+ */
+export const CALMING = {
+    features: /^flow\.[a-z]$|^(turn|softness)$/,
+    lists: {
+        // Glow, Arc, Bloom, Drift, Horizon, Split, Swirl, Break, then Veil, Rise, Rings and Streak.
+        flow: [12, 8, [0, 3, 8, 5, 1, 7, 4, 6, 9, 10, 11, 2]],
+    },
+};
+/**
+ * Each type's palettes, plainest first, which Possibilities keeps eight of at the lowest. For
+ * skies, the gentle daytime ones, then dusk, and night last; for auras, the soft pastels, then
+ * the deep.
+ */
+export const PALETTE_ORDER = {
+    // Clear, Dawn, Mist, Noon, Pastel, Haze, Golden, Dusk, then Evening, Orchid, Ember and Night.
+    Sky: [0, 2, 8, 5, 4, 11, 6, 9, 1, 10, 3, 7],
+    // Sunrise, Meadow, Twilight, Sky, Dream, Blossom, Fern, Craft, then Flowy, Mint, Ember,
+    // Aurora, Nebula, Cobalt and Forest.
+    Aura: [0, 2, 5, 8, 6, 3, 13, 9, 11, 14, 1, 4, 7, 10, 12],
+};
+export const NOTES = [
+    "calm glows and gentle daytime skies, upright, nearly smooth, the horizon in its place.",
+    "more formations and skies, grainier, the horizon higher or lower.",
+    "every formation and sky, up to the deepest and night, at any grain and horizon.",
+];

package/dist/auras/controls.d.ts

@@ -0,0 +1,2 @@
+import { type ControlBuilder } from "../controls.ts";
+export declare const controls: ControlBuilder;

package/dist/auras/controls.js

@@ -0,0 +1,60 @@
+import { choice, clearingColor, slider } from "../controls.js";
+import { narrowed, possibilitiesSlider } from "../possibilities.js";
+import { colorKey } from "../traits.js";
+import { CALMING, NOTES } from "./calming.js";
+import { auraTraits, coloursOf, FACES, faceOf, flowOf, FLOWS, horizonOf, paletteOf, palettesOf, palettesOffered, PARTS, TYPES, typeOf } from "./index.js";
+export const controls = (name, overrides) => {
+    const t = auraTraits(name, overrides);
+    const type = typeOf(name, overrides);
+    const colours = coloursOf(name, overrides, t, type);
+    const face = faceOf(t);
+    const sky = type === "Sky";
+    // A sky's palette swatch is the sky itself, top to bottom; an aura's shows its four colours.
+    const swatch = ({ colors, stops }) => stops ? `linear-gradient(${stops.join(", ")})` : `conic-gradient(${colors.map((color, i) => `${color} 0 ${(i + 1) * 25}%`).join(", ")})`;
+    return [
+        {
+            title: "Aura",
+            controls: [
+                // Each showing what's drawn, which for a variant is a step on from its name's own.
+                { ...choice(t, "type", "Type", "list", TYPES.map((label) => ({ label }))), selected: String(TYPES.indexOf(type)) },
+                ...(sky
+                    ? []
+                    : [{ ...narrowed(choice(t, "flow", "Formation", "list", FLOWS.map(({ name: label }) => ({ label }))), t, CALMING), selected: String(FLOWS.indexOf(flowOf(name, overrides))) }]),
+                // A new palette starts from its own colours, not the ones set by hand for the last.
+                (() => {
+                    const control = PARTS.reduce(clearingColor, choice(t, "palette", sky ? "Sky" : "Palette", "swatches", palettesOf(type).map((palette) => ({ label: palette.label, color: swatch(palette) }))));
+                    const selected = String(paletteOf(name, overrides, type));
+                    // Only those Possibilities offers, plus the one drawn, as with Formation.
+                    const offered = new Set(palettesOffered(t, type).map(String));
+                    return { ...control, selected, options: control.options.filter((option) => offered.has(option.id) || option.id === selected) };
+                })(),
+                // Up front for a sky, beside its palette. Level with the reference's until moved.
+                ...(sky
+                    ? [{
+                            type: "slider",
+                            id: "horizon",
+                            label: "Horizon",
+                            value: (horizonOf(t) + 1) / 2,
+                            display: `${Math.round(horizonOf(t) * 100)}%`,
+                            range: [-100, 100],
+                            ends: ["Lower", "Higher"],
+                        }]
+                    : []),
+                { type: "colors", id: "aura.colors", label: "Colours", colors: PARTS.map((part) => ({ id: colorKey(part), color: colours[part] })) },
+                possibilitiesSlider(t, NOTES),
+                slider(t, "grain", "Grain", 0, 100, "%"),
+                ...(sky ? [] : [slider(t, "softness", "Softness", 0, 100, "%"), slider(t, "turn", "Turn", -30, 30, "°")]),
+            ],
+        },
+        {
+            title: "Face",
+            controls: [
+                {
+                    ...choice(t, "face", "Face", "list", FACES.map((label) => ({ label }))),
+                    // None until one is picked, whatever the name, as the reference's tiles have none.
+                    selected: String(FACES.indexOf(face)),
+                },
+            ],
+        },
+    ];
+};

package/dist/auras/index.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Auras: a rounded tile of colour, after the reference. Two to four colours melt into each
+ * other with no edge anywhere, in a formation of their own: a glow, a horizon, a streak, an
+ * arc, a swirl. A fine film grain lies over it all, which also hides any banding in the blend.
+ *
+ * The colour is a few soft shapes, blurred together as one layer. That layer is drawn once
+ * and only ever moved and turned, so the costly blur is never redone as it reacts.
+ *
+ * A sky is its other type, as the animals are each a type of their own: smooth gradient from
+ * top to bottom, after the second reference's times of day and weathers. Both are a rounded tile.
+ */
+import { type Overrides, type Traits } from "../traits.ts";
+export { SKIES } from "./skies.ts";
+/** Each with a reference of its own: a tile of melted colour, or a circle of sky. */
+export declare const TYPES: readonly ["Aura", "Sky"];
+export type Type = (typeof TYPES)[number];
+/**
+ * Each as deep, mid, light and accent. The first nine are the first reference's, and the rest
+ * after the later ones: Craft's greens on cream, Flowy's sunrise, a fern green with pale rings,
+ * and three from the sprayed posters, lime on forest, mint on green and pale blue on cobalt.
+ */
+export declare const PALETTES: {
+    label: string;
+    colors: string[];
+}[];
+/** Which of a palette's colours each part is, and each can be changed by hand. */
+export declare const PARTS: string[];
+type Colours = {
+    deep: string;
+    mid: string;
+    light: string;
+    accent: string;
+};
+/** A soft shape, before the blur: an oval, or a thick stroke along a path. */
+type Blob = {
+    kind: "oval";
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    turn: number;
+    color: string;
+    opacity?: number;
+} | {
+    kind: "stroke";
+    d: string;
+    width: number;
+    color: string;
+    opacity?: number;
+};
+/** Moves a point by up to `amount` either way, from the name. */
+type Jitter = (key: string, amount: number) => number;
+interface Flow {
+    name: string;
+    /** Which colour fills behind everything. */
+    base: (c: Colours) => string;
+    blobs: (c: Colours, j: Jitter) => Blob[];
+    /** How much of the usual blur it takes, for one whose shapes must still show through. */
+    softness?: number;
+}
+/** The formations, after the reference's tiles. Neighbours are as unlike as they can be. */
+export declare const FLOWS: Flow[];
+export declare const auraTraits: (name: string, overrides?: Overrides) => Traits;
+/** A name's type. Its variants take turns, an aura then a sky, so a strip has both. */
+export declare const typeOf: (name: string, overrides?: Overrides) => Type;
+/** An aura's formation. A strip of variants never repeats one. */
+export declare const flowOf: (name: string, overrides?: Overrides) => Flow;
+/** The palettes a type offers: an aura's, or the skies, with their four colours to pick by hand. */
+export declare const palettesOf: (type: Type) => {
+    label: string;
+    colors: string[];
+    stops?: string[];
+}[];
+/**
+ * How far the horizon is moved, from -1 (lower) to 1 (higher). It sits as in the reference
+ * until Possibilities is moved, and then strays from it by the name, further the higher it is.
+ * Set by hand, it's that.
+ */
+export declare function horizonOf(t: Traits): number;
+/** Which of its type's palettes it has. Variants step on through them, each type's its own. */
+export declare const paletteOf: (name: string, overrides: Overrides | undefined, type: Type) => number;
+/** The palettes Possibilities offers a type, plainest first: all of them until it's moved. */
+export declare function palettesOffered(t: Traits, type: Type): number[];
+/** The palette's colours, each of which can be changed by hand. A sky's are its stops, top to bottom. */
+export declare function coloursOf(name: string, overrides: Overrides | undefined, t: Traits, type: Type): Colours;
+/** A plain face, which is off unless picked: the reference's tiles have none. */
+export declare const FACES: readonly ["None", "Dots", "Calm", "Smile"];
+export declare const faceOf: (t: Traits) => "Calm" | "Dots" | "None" | "Smile";
+export interface Aura {
+    type: Type;
+    /**
+     * The colour layer, with its own ids from `id`: an aura's soft shapes, over a fill reaching
+     * well past the tile so its edges never fade, or a sky's gradient, held at its ends beyond it.
+     */
+    colour: (id: string) => string;
+    /** How far the shapes are blurred together, and how heavy the grain over them is. */
+    blur: number;
+    grain: number;
+    /** The noise's seed, so each name's grain is its own. */
+    seed: number;
+    /** The formation's turn, in degrees. */
+    turn: number;
+    face: {
+        eyes: string;
+        mouth: string;
+    };
+    blinkDelay: number;
+}
+export declare function createAura(name: string, overrides?: Overrides): Aura;
+/** The colour layer as drawn: blurred and turned for an aura, and as it is for a sky. */
+export declare const colourLayer: (aura: Aura, id: string) => string;
+/** How the face is drawn, over the colour. */
+export declare const FACE_STYLE = "fill=\"#ffffff\" stroke=\"#ffffff\" stroke-width=\"2.6\" stroke-linecap=\"round\" stroke-linejoin=\"round\" opacity=\"0.92\"";
+/** The grain as a filter, at `frequency` cycles a unit: fine, grey, and wholly opaque, to be laid on in overlay. */
+export declare const grainFilter: (id: string, frequency: number, seed: number) => string;
+/** The colour layer's blur. Its region reaches well past the tile, so nothing is clipped before it's blurred. */
+export declare const blurFilter: (id: string, blur: number) => string;
+/** The tile at rest, for thumbnails. */
+export declare function auraSvg(name: string, overrides?: Overrides): string;