@harmonics/lattice-ui 0.0.0-stage → 0.4.0

package/dist/types/elements/index.d.ts

@@ -0,0 +1,31 @@
+import { defineLatticeFace, LatticeFace } from "./face";
+import { defineLatticeIcon, LatticeIcon } from "./icon";
+import { defineLatticeShape, LatticeShape } from "./shape";
+import { defineShearsPad, ShearsPadElement, type StrokeDetail } from "./shears";
+import { defineHexSky, HexSky } from "./sky";
+export { FACES } from "../faceLattice";
+export type { Part } from "../hexes";
+export { FACE_TAG, MOODS } from "./face";
+export { ICON_NAMES, ICON_TAG, type IconName } from "./icon";
+export { SHAPE_TAG } from "./shape";
+export { SHAPE_NAMES, type ShapeName, TONES } from "./shapes";
+export { SHEARS_TAG, type StrokePoint } from "./shears";
+export { SKY_TAG } from "./sky";
+export { defineHexSky, defineLatticeFace, defineLatticeIcon, defineLatticeShape, defineShearsPad, HexSky, LatticeFace, LatticeIcon, LatticeShape, ShearsPadElement, type StrokeDetail, };
+/** Register every element once; a second call, or a call on a server, does nothing. */
+export declare function defineLatticeElements(): void;
+declare global {
+    interface HTMLElementTagNameMap {
+        "lattice-face": LatticeFace;
+        "hex-sky": HexSky;
+        "lattice-shape": LatticeShape;
+        "shears-pad": ShearsPadElement;
+        "lattice-icon": LatticeIcon;
+    }
+    interface HTMLElementEventMap {
+        stroke: CustomEvent<StrokeDetail>;
+        strokeend: CustomEvent<{
+            points: StrokeDetail["points"];
+        }>;
+    }
+}

package/dist/types/elements/shape.d.ts

@@ -0,0 +1,29 @@
+import type { Part } from "../hexes";
+import { LatticeElement } from "./host";
+import { type ShapeName } from "./shapes";
+export declare const SHAPE_TAG = "lattice-shape";
+export declare class LatticeShape extends LatticeElement {
+    static readonly observedAttributes: string[];
+    private readonly shapeSignal;
+    private readonly partsSignal;
+    private readonly toneSignal;
+    private readonly liftSignal;
+    private readonly scaleSignal;
+    private readonly labelSignal;
+    get shape(): ShapeName;
+    set shape(name: string);
+    /** The parts drawn: those given, or the shape's. */
+    get parts(): Part[];
+    set parts(parts: unknown);
+    get tone(): number;
+    set tone(tone: number | string);
+    get lift(): number;
+    set lift(lift: number | string);
+    get scale(): number;
+    set scale(scale: number | string);
+    get label(): string;
+    set label(label: string);
+    attributeChangedCallback(name: string, _: string | null, value: string | null): void;
+}
+/** Register `<lattice-shape>` once; a second call, or a call on a server, does nothing. */
+export declare const defineLatticeShape: () => void;

package/dist/types/elements/shapes.d.ts

@@ -0,0 +1,45 @@
+import { type FlatFace, type Part } from "../hexes";
+/** The woods a part can be cut from: 0 to 4 the tree's, 5 to 7 its fruit (FRUIT in hexes.ts). */
+export declare const TONES = 8;
+/** Each ready-made shape, in one wood. */
+export declare const SHAPES: {
+    /** One cell. */
+    cell: (tone: number) => Part[];
+    /** Two cells side by side. */
+    pair: (tone: number) => Part[];
+    /** Three cells in a row. */
+    line: (tone: number) => Part[];
+    /** A cell and the six round it. */
+    flower: (tone: number) => Part[];
+    /** One triangle. */
+    triangle: (tone: number) => Part[];
+    /** Two triangles sharing a side. */
+    diamond: (tone: number) => Part[];
+    /** Three triangles in a strip. */
+    trapezoid: (tone: number) => Part[];
+    /** Four triangles: a triangle twice the size. */
+    "big-triangle": (tone: number) => Part[];
+    /** Six triangles round a corner: a hexagon that can stand off the cells. */
+    hexagon: (tone: number) => Part[];
+};
+export type ShapeName = keyof typeof SHAPES;
+export declare const SHAPE_NAMES: ShapeName[];
+/** A wood, kept to the ones there are. */
+export declare const toneOf: (tone: number) => number;
+/**
+ * Parts from anything a page may hand over (a property, or JSON in an attribute): each a cell
+ * `{kind: "cell", at: {q, r}}` or a triangle `{kind: "tri", at: {i, j, k}}`, with an optional
+ * `tone`. Whatever is not one is left out.
+ */
+export declare function partsFrom(value: unknown, tone: number): Part[];
+/** A shape drawn on its own: its faces, its seams, and the box round them with `pad` to spare. */
+export declare function drawingOf(parts: Part[], lift: number, pad?: number): {
+    faces: FlatFace[];
+    seams: string;
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};

package/dist/types/elements/shears.d.ts

@@ -0,0 +1,20 @@
+import { LatticeElement } from "./host";
+export declare const SHEARS_TAG = "shears-pad";
+/** A point in the element's own pixels, from its top-left. */
+export type StrokePoint = {
+    x: number;
+    y: number;
+};
+export interface StrokeDetail {
+    points: StrokePoint[];
+    fresh: boolean;
+}
+export declare class ShearsPadElement extends LatticeElement {
+    static readonly observedAttributes: string[];
+    private readonly disabledSignal;
+    get disabled(): boolean;
+    set disabled(disabled: boolean | string | null);
+    attributeChangedCallback(_: string, __: string | null, value: string | null): void;
+}
+/** Register `<shears-pad>` once; a second call, or a call on a server, does nothing. */
+export declare const defineShearsPad: () => void;

package/dist/types/elements/sky.d.ts

@@ -0,0 +1,20 @@
+import { LatticeElement } from "./host";
+export declare const SKY_TAG = "hex-sky";
+export declare class HexSky extends LatticeElement {
+    static readonly observedAttributes: string[];
+    private readonly kindSignal;
+    private readonly scaleSignal;
+    private readonly xSignal;
+    private readonly ySignal;
+    get kind(): "sky" | "earth";
+    set kind(kind: string);
+    get scale(): number;
+    set scale(scale: number | string);
+    get x(): number;
+    set x(x: number | string);
+    get y(): number;
+    set y(y: number | string);
+    attributeChangedCallback(name: string, _: string | null, value: string | null): void;
+}
+/** Register `<hex-sky>` once; a second call, or a call on a server, does nothing. */
+export declare const defineHexSky: () => void;

package/dist/types/elements/solid.d.ts

@@ -0,0 +1,46 @@
+import type { HexSky, IconName, LatticeFace, LatticeIcon, LatticeShape, Part, ShapeName, ShearsPadElement, StrokeDetail, StrokePoint } from "./index";
+declare module "solid-js" {
+    namespace JSX {
+        interface IntrinsicElements {
+            "lattice-face": JSX.HTMLAttributes<LatticeFace> & {
+                mood?: LatticeFace["mood"];
+                expression?: string;
+                pulse?: number | string;
+                still?: boolean;
+                size?: number | string;
+                label?: string;
+                decorative?: boolean;
+            };
+            "hex-sky": JSX.HTMLAttributes<HexSky> & {
+                kind?: "sky" | "earth";
+                scale?: number | string;
+                x?: number | string;
+                y?: number | string;
+            };
+            "lattice-shape": JSX.HTMLAttributes<LatticeShape> & {
+                shape?: ShapeName;
+                parts?: string;
+                tone?: number | string;
+                lift?: number | string;
+                scale?: number | string;
+                label?: string;
+            };
+            "shears-pad": JSX.HTMLAttributes<ShearsPadElement> & {
+                disabled?: boolean;
+            };
+            "lattice-icon": JSX.HTMLAttributes<LatticeIcon> & {
+                name?: IconName;
+                label?: string;
+            };
+        }
+        interface ExplicitProperties {
+            parts: Part[] | string;
+        }
+        interface CustomEvents {
+            stroke: CustomEvent<StrokeDetail>;
+            strokeend: CustomEvent<{
+                points: StrokePoint[];
+            }>;
+        }
+    }
+}

package/dist/types/faceLattice.d.ts

@@ -0,0 +1,56 @@
+export type Point = {
+    x: number;
+    y: number;
+};
+export declare const SQ3: number;
+export declare const ring: (ps: Point[]) => string;
+/** Every hexagon here is this far from its middle to each corner. */
+export declare const R = 120;
+/** What a triangle is: plate, or part of a feature. The stylesheet colours each. */
+export type Ink = "plate" | "ink" | "glint" | "blush" | "tear" | "tongue";
+export interface Tri {
+    corners: Point[];
+    /** Its middle, as a share of R: the face is described in those units. */
+    mid: Point;
+    /** Its top-left corner on the lattice, and which way it points (0 right, 1 left). */
+    i: number;
+    j: number;
+    k: 0 | 1;
+}
+/** How far a point (in units of R) is from another, as a pointy-top hexagon measures it. */
+export declare function hexD(p: Point, c?: Point): number;
+/** The hexagon's triangles, `n` to a side. */
+export declare function trianglesOf(n: number): Tri[];
+type Region = (p: Point) => boolean;
+/** A face: its layers, in order; a triangle takes the last one it falls in. */
+export type Face = [Ink, Region][];
+export interface Expression {
+    name: string;
+    /** What it does while it idles, in a word. */
+    idle: string;
+    at: (t: number) => Face;
+}
+export declare const FACES: Expression[];
+/** What each triangle of a lattice is, for a face. */
+export declare const inkOf: (face: Face, tri: Tri, n: number) => Ink;
+/** How a face is lit. */
+export type Depth = "flat" | "raised" | "carved" | "cubes";
+export type Shade = "top" | "left" | "right";
+/**
+ * Every triangle's ink and shade for a face at depth `n`:
+ * - raised, every feature stands a step or two off the plate, its sides below it in shade;
+ * - carved, every feature is cut into the plate, its far wall showing inside its top edge;
+ * - cubes, every feature is built of cubes seen from above: each triangle shaded by which third
+ *   of its hexagon of the lattice it is in, as three diamonds make a cube.
+ */
+export declare function shadedOf(face: Face, n: number, depth: Depth): {
+    inks: Ink[];
+    shades: Shade[];
+};
+/** The paths of a lattice, one per ink and shade. */
+export declare function paths(tris: Tri[], inks: Ink[], shades?: Shade[]): {
+    ink: Ink;
+    shade: Shade;
+    d: string;
+}[];
+export {};

package/dist/types/hexes.d.ts

@@ -0,0 +1,370 @@
+/** A cell of the lattice, by axial coordinates. */
+export interface Hex {
+    q: number;
+    r: number;
+}
+/** A corner of the triangle grid. */
+export interface Corner {
+    i: number;
+    j: number;
+}
+/** A triangle: the corner at its top-left, and which way it points (0 right, 1 left). */
+export interface Tri extends Corner {
+    k: 0 | 1;
+}
+/** One part of a piece: a cell or a triangle, and the wood it is cut from. */
+export type Part = {
+    kind: "cell";
+    at: Hex;
+    tone: number;
+} | {
+    kind: "tri";
+    at: Tri;
+    tone: number;
+};
+/**
+ * A piece: its parts, side by side, and the corner it turns about. A piece with a cell turns about
+ * a cell's centre, so its cells stay on cells; the corner is chosen when the piece is made, glued
+ * or split, and moves with it, so a turn and its opposite always undo each other.
+ */
+export interface Piece {
+    id: string;
+    parts: Part[];
+    pivot: Corner;
+}
+/** The top-left of a cell's box on the screen, where its prism is drawn from. */
+export declare function boxOf(hex: Hex): {
+    x: number;
+    y: number;
+};
+/** Where a corner of the triangle grid is on the screen. */
+export declare function cornerOf(corner: Corner): {
+    x: number;
+    y: number;
+};
+/** A triangle's three corners, as grid corners: clockwise from its top-left. */
+export declare function cornersOf(tri: Tri): [Corner, Corner, Corner];
+/** The cell under a point on the screen: the nearest cell centre, by cube rounding. */
+export declare function hexAt(x: number, y: number): Hex;
+/** The corner of the triangle grid nearest a point on the screen. */
+export declare function cornerAt(x: number, y: number): Corner;
+/** The corner at a cell's centre. */
+export declare function centreOf(hex: Hex): Corner;
+/** The six triangles of a cell, centre to corners. */
+export declare function trisOf(hex: Hex): Tri[];
+/** The part of the sky on the screen, in the sky's own coordinates: zoomed, it is not the screen's. */
+export interface Area {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/** The sky a screen `width` by `height` shows unzoomed. */
+export declare const screenArea: (width: number, height: number) => Area;
+/** The triangles one part covers: a cell's six, or the triangle itself. */
+export declare const trisOfPart: (part: Part) => Tri[];
+/** The triangles a piece covers. */
+export declare function covered(piece: Piece): Tri[];
+/** The bottom of a piece's lowest corner on the screen: pieces are drawn in that order. */
+export declare function bottomOf(piece: Piece): number;
+/**
+ * Whether `piece` may stand where it is: every triangle whole on the screen (`width` by
+ * `height`), and none of them taken by another piece or by a cell kept clear.
+ */
+export declare function fits(piece: Piece, pieces: Piece[], area: Area, clear?: Hex[]): boolean;
+/** The piece moved by `delta`: every part and its pivot. A piece with a cell moves only whole cells. */
+export declare function moved(piece: Piece, delta: Corner): Piece;
+/** The piece a piece was moved from, first of all, and how far on the screen: itself, if none. */
+export declare function slidOf(piece: Piece): {
+    from: Piece;
+    dx: number;
+    dy: number;
+};
+/** The whole-cell step nearest a move of (dx, dy) on the screen. */
+export declare function cellStep(dx: number, dy: number): Corner;
+/** The step a pointer's move of (dx, dy) on the screen comes to: the nearest one the piece can take. */
+export declare function snapDelta(piece: Piece, dx: number, dy: number): Corner;
+/**
+ * How the slots pull, as parts of a piece's unit (a cell across, or a triangle's side): how far a
+ * slot reaches, how near catches and holds, how far a held piece must be tugged to come free (more
+ * than catches it, so it never flickers at the edge), and how far it leans in before it is caught.
+ */
+export declare const MAGNET: {
+    readonly reach: 0.5;
+    readonly capture: 0.3;
+    readonly release: 0.5;
+    readonly lean: 0.6;
+};
+/** Where a carried piece is drawn, and the slot it would land in. */
+export interface Magnet {
+    /** The slot: the step from where the piece was lifted. */
+    step: Corner;
+    /** Where to draw it, as a move from where it was lifted, on the screen. */
+    x: number;
+    y: number;
+    /** How hard the slot pulls, 0 to 1: 1 while held. */
+    pull: number;
+    /** The slot it is held in, to hand back on the next move; none while it only leans. */
+    held: Corner | undefined;
+}
+/**
+ * A carried piece moved (dx, dy) by the pointer since it was lifted, and held in `held` before:
+ * where it is drawn and where it would land. Near a slot it leans in; nearer, the slot catches it
+ * and it is drawn there exactly; it stays caught until it is tugged past `MAGNET.release`.
+ */
+export declare function magnetOf(piece: Piece, dx: number, dy: number, held?: Corner): Magnet;
+/**
+ * The click into a slot: keyframes (Web Animations) that bring a piece from `from` (how far it is
+ * off, on the screen) to rest, passing it by `overshoot` of the way and settling back.
+ */
+export declare function snapFrames(from: {
+    x: number;
+    y: number;
+}, overshoot?: number): {
+    transform: string;
+    offset: number;
+    easing?: string;
+}[];
+/** How the arrow keys step a piece: a cell, or a triangle's side, in each direction. */
+export declare function stepFor(piece: Piece, key: string): Corner | undefined;
+/** The piece turned `turns` sixths clockwise (negative: anticlockwise) about its pivot. */
+export declare function turned(piece: Piece, turns: number): Piece;
+/** Where a piece turns on the screen. */
+export declare const pivotPoint: (piece: Piece) => {
+    x: number;
+    y: number;
+};
+/** A piece of these parts, with its pivot chosen. */
+export declare const pieceOf: (id: string, parts: Part[]) => Piece;
+/** Whether two pieces share a side: touching at a corner is not touching. The smaller is walked. */
+export declare const touching: (a: Piece, b: Piece) => boolean;
+/** The sides two pieces share, each as its two corners on the screen. */
+export declare function sharedSides(a: Piece, b: Piece): [{
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}][];
+/** The sides shared between a piece's own parts, on the screen: where it is glued. */
+export declare function seamsOf(piece: Piece): [{
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}][];
+/** `piece` glued to every piece it touches: one piece, its parts each keeping their wood. */
+export declare function glued(piece: Piece, others: Piece[]): {
+    piece: Piece;
+    absorbed: string[];
+};
+/**
+ * One part pulled off a piece: that part as a piece of its own, then what is left, as one piece or
+ * several if the part held them together.
+ */
+export declare function pulledOff(piece: Piece, index: number, id: () => string): Piece[];
+/** A piece broken into its units, each a piece of its own. */
+export declare const apart: (piece: Piece, id: () => string) => Piece[];
+/**
+ * The nearest place `piece` fits, searching outward from where it is, ring by ring, up to `rings`
+ * steps away; undefined when nothing that near fits.
+ */
+export declare function nearestFit(piece: Piece, pieces: Piece[], area: Area, clear?: Hex[], rings?: number, 
+/** A further test a place must pass: to stand clear of other pieces, say. */
+also?: (at: Piece) => boolean): Piece | undefined;
+/** How far a step moves a piece on the screen. */
+export declare const stepOnScreen: (delta: Corner) => {
+    x: number;
+    y: number;
+};
+/** The parts of `piece` that cannot stand where they are: off the screen, or on something taken. */
+export declare function blockedParts(piece: Piece, pieces: Piece[], area: Area, clear?: Hex[]): Set<number>;
+/** A piece's outer edge, as the sides on the screen that no other part of it shares. */
+export declare function outlineOf(piece: Piece): [{
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}][];
+/**
+ * The pieces, every one on the screen and none overlapping, as near as can be to where they stood.
+ * Pieces that touch move together, by the same step, so a built thing stays whole. The biggest
+ * groups claim their room first; a group that is off the screen, or now overlaps one placed before
+ * it, is shifted by as much as it overhangs and then to the nearest place it fits. A group with
+ * nowhere to go stays where it was.
+ */
+export declare function intoView(pieces: Piece[], area: Area, clear?: Hex[], 
+/** Pieces that stay where they are, as the tree does: the others keep clear of them. */
+fixed?: Piece[]): Piece[];
+/** A new cell, or a new triangle, standing on the cell under a point. */
+export declare function unitAt(kind: "cell" | "tri", x: number, y: number, tone: number, id: string): Piece;
+/** A clump of leaves, as an ellipse: its middle, its two radii, and how dry it is (0 to 1). */
+type Clump = [number, number, number, number, number];
+/** A stretch of wood: a line, with its width at either end. */
+type Limb = [number, number, number, number, number, number];
+/** What a tree is grown from, in its own pixels from the foot. */
+export interface Growth {
+    /** Where each group's limb ends, in the groups' order: its branches hang there. */
+    ends: {
+        x: number;
+        y: number;
+    }[];
+    limbs: Limb[];
+    clumps: Clump[];
+    /** Things done lately, harvested on the ground: good, bitter, or not yet tasted. */
+    fruit: (boolean | undefined)[];
+    /** Things cut lately, lying as mulch at the trunk's foot, away from the harvest. */
+    mulch: number;
+    /** A face on the trunk: its low hollow, where the face is, is filled in. */
+    face: boolean;
+}
+/** How the tree is doing, as far as its shape shows it. Each list is per group, in order. */
+export interface Shape {
+    /** How stale what each carries is, 0 (fresh) to 1 (all stale): its leaves yellow and thin. */
+    stale?: number[];
+    /** How far past what its root can carry each is, as a share of it: its limb droops. */
+    over?: number[];
+    /** The last group grows from no root: suckers from the trunk's foot, not a limb of the crown. */
+    wild?: boolean;
+    /** Each feeds the person: its limb puts out fresh leaves where it bends and where it ends. */
+    soul?: boolean[];
+    fruit?: (boolean | undefined)[];
+    mulch?: number;
+    face?: boolean;
+}
+/**
+ * A tree for groups that carry `counts` branches each, in order: a limb each, their ends fanned
+ * evenly left to right and highest in the middle, each limb thicker the more it carries and ending
+ * in a clump of leaves the size of what hangs there. Its `shape` says how it is doing: a limb past
+ * what its root can carry droops on wood too thin for it, and the trunk thins with the heaviest;
+ * a stale group's leaves yellow and thin; branches with no root grow as suckers from the foot; a
+ * tree with nothing on it is bare limbs, and one with no roots a sprout.
+ */
+export declare function growthFor(counts: number[], shape?: Shape): Growth;
+/**
+ * The tones of fruit, past the five woods: drawn at full strength, not as a wash like the wood, so
+ * a harvest reads on the ground (styles.css).
+ */
+export declare const FRUIT: {
+    readonly good: 5;
+    readonly bitter: 6;
+    readonly untasted: 7;
+};
+/**
+ * Where the nth thing done lies in the harvest, left of the trunk: a row of eight, then the next
+ * row up. The olive is this triangle and the one across its upright side.
+ */
+export declare function harvestSpot(n: number, foot?: {
+    x: number;
+    y: number;
+}): Tri;
+/** The tones of mulch, past the fruit's: walnut and ochre at full strength, turn about. */
+export declare const MULCH: readonly [8, 9];
+/**
+ * The triangles `n` things cut lately lie on, as a heap at the trunk's foot: those nearest its
+ * middle first, flatter than tall, so a few make a mound and many a wider one.
+ */
+export declare function mulchSpots(n: number, foot?: {
+    x: number;
+    y: number;
+}): Tri[];
+/** How many set-aside things stand on the ground as saplings; the rest wait behind the last. */
+export declare const SAPLINGS_SHOWN = 5;
+/**
+ * The cells `n` set-aside things stand on as saplings: a row on the ground right of the mulch,
+ * side by side, out from the trunk; never more than `SAPLINGS_SHOWN`.
+ */
+export declare function saplingSpots(n: number, foot?: {
+    x: number;
+    y: number;
+}): Hex[];
+/** Where the tree's foot stands on the sky when the page does not say: a laptop's screen. */
+export declare const FOOT: {
+    x: number;
+    y: number;
+};
+/** A point of the tree, from its foot in its own pixels, on the sky. */
+export declare const skyOf: (p: {
+    x: number;
+    y: number;
+}, foot?: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+};
+/** How far the crown reaches to either side, on the sky. */
+export declare function crownSpan(growth: Growth, foot?: {
+    x: number;
+    y: number;
+}): {
+    left: number;
+    right: number;
+};
+/** An olive tree: its crown, its trunk and its ground, three pieces of cells and triangles. */
+export declare function oliveTree(id: () => string, foot?: {
+    x: number;
+    y: number;
+}, growth?: Growth): Piece[];
+/** Two cells and two triangles, loose on the sky's top-left, so there is something to glue at once. */
+export declare function startingPieces(id: () => string): Piece[];
+/**
+ * The cells each root's branches stand on, `counts[k]` of them round the end of limb k, in
+ * reading order: top row first, left to right, so a root's list reads as its cells do. A root
+ * that carries more than `held[k]` packs only that many; the rest hang below the cluster, one under
+ * another with sky between, outside what the limb holds up.
+ */
+export declare function clustersOf(growth: Growth, counts: number[], foot?: {
+    x: number;
+    y: number;
+}, held?: (number | undefined)[]): Hex[][];
+/** A cell's six triangles in reading order: clockwise, from the one at its upper right. */
+export declare function stepTris(hex: Hex): Tri[];
+/** One merged face of a flat piece: every side face of one shade, or every top, of one wood. */
+export interface FlatFace {
+    tone: number;
+    kind: "shade" | "shadow" | "top";
+    d: string;
+}
+/** A piece standing `lift` off the sky as merged paths, side faces first, and its glued seams. */
+export declare function flatFaces(piece: Piece, lift: number): {
+    faces: FlatFace[];
+    seams: string;
+};
+type Pt = {
+    x: number;
+    y: number;
+};
+/**
+ * Whether a stroke goes clean through a closed outline: in at one side and out at another. A
+ * stroke that only grazes a corner, or stops inside, does not.
+ */
+export declare function crossesRing(stroke: Pt[], ring: Pt[]): boolean;
+/** Whether a stroke, as points on the sky, goes clean through a cell standing `lift` off it. */
+export declare function crossesCell(stroke: Pt[], hex: Hex, lift?: number): boolean;
+/** Whether a stroke crosses a line of points anywhere. */
+export declare function crossesLine(stroke: Pt[], line: Pt[]): boolean;
+/** What the face shows. */
+export type Mood = "happy" | "content" | "asleep" | "sad" | "distressed" | "puzzled" | "relieved";
+/** The tree's state, as the model reads it, as a face. `over` is how far past it can carry, 0–1+. */
+export declare function moodOf(kind: "bare" | "planted" | "overrun" | "lofty" | "withering" | "bearing" | "steady", over?: number): Mood;
+/** Where the plate stands: its middle, on a cell's centre, so its sides lie on the lattice. */
+export declare function faceCentre(foot?: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+/** The plate's six corners, clockwise from its top. */
+export declare function plateOf(foot?: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+}[];
+export {};

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@harmonics/lattice-ui",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "description": "The Harmonics tree's look as Custom Elements: a lattice face, the hexagon sky, raised lattice shapes, a shears cut gesture and two marks. Any page, any framework.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": [
+    "./dist/define.js"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/elements/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./define": {
+      "types": "./dist/types/elements/define.d.ts",
+      "default": "./dist/define.js"
+    },
+    "./hexes": {
+      "types": "./dist/types/elements/hexes.d.ts",
+      "default": "./dist/hexes.js"
+    },
+    "./react": {
+      "types": "./react.d.ts"
+    },
+    "./solid": {
+      "types": "./dist/types/elements/solid.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/*.js",
+    "dist/types",
+    "react.d.ts",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "custom-elements",
+    "web-components",
+    "hexagon",
+    "lattice",
+    "svg"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Blankenship-Daniel/harmonics.git",
+    "directory": "packages/lattice-ui/kit"
+  }
+}