mudlet-map-renderer 1.0.0 → 1.2.0

package/dist/scene/Shape.d.ts

@@ -0,0 +1,151 @@
+/**
+ * SceneIR — pure data shapes that {@link ScenePipeline} produces.
+ *
+ * Shapes carry world-space coordinates and engine-agnostic paint information.
+ * They are consumed by:
+ *   - {@link CullingManager} (visibility queries against a camera viewport)
+ *   - {@link HitTester} (point→shape lookup)
+ *   - {@link DrawCommandBuilder} (translation to engine {@link DrawCommand}s)
+ *
+ * Shapes know nothing about Konva, SVG, or Canvas2D.
+ */
+/** Logical layer for stacking. Mapped to engine-specific layers by renderers. */
+export type LayerId = "grid" | "link" | "room" | "position" | "overlay" | "top";
+/** Engine-agnostic paint description. */
+export interface Paint {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    dash?: number[];
+    dashEnabled?: boolean;
+    /** 0..1 multiplier on fill+stroke. */
+    alpha?: number;
+}
+/** Hit-test annotation. Set on shapes that should be pickable. */
+export interface HitInfo {
+    /** What the shape represents at the model layer. */
+    kind: "room" | "exit" | "specialExit" | "stub" | "label" | "areaExit" | string;
+    /** Identifier of the owning model entity (room id, exit id, …). */
+    id?: number | string;
+    /** Free-form payload returned to callers from {@link HitTester}. */
+    payload?: unknown;
+    /**
+     * Multiplier on the current `roomSize` for the maximum pick distance.
+     * Smaller = stricter (used for thin geometry like exits and stubs).
+     * Defaults to a per-kind value when omitted (rooms 1.0, exits 0.35, stubs 0.3, …).
+     */
+    margin?: number;
+    /**
+     * Tiebreaker when multiple hits are within range. Higher = on top.
+     * Defaults to a per-kind value when omitted (rooms over exits over stubs, …).
+     */
+    priority?: number;
+}
+/** Common fields on every shape. */
+export interface ShapeBase {
+    /** Logical layer; defaults to "room" when omitted. */
+    layer?: LayerId;
+    /** Set on shapes that participate in hit testing. */
+    hit?: HitInfo;
+    /**
+     * If true, the shape renders at a fixed pixel size regardless of camera
+     * zoom. Mirrors the legacy `GroupNode.noScaling` flag.
+     */
+    noScale?: boolean;
+}
+export interface RectShape extends ShapeBase {
+    type: "rect";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    cornerRadius?: number;
+    paint: Paint;
+}
+export interface CircleShape extends ShapeBase {
+    type: "circle";
+    cx: number;
+    cy: number;
+    radius: number;
+    paint: Paint;
+}
+export interface LineShape extends ShapeBase {
+    type: "line";
+    /** Flat list of [x0, y0, x1, y1, …]. */
+    points: number[];
+    paint: Paint;
+    lineCap?: "butt" | "round" | "square";
+    lineJoin?: "miter" | "round" | "bevel";
+    /**
+     * Marks lines that are infrastructure (grid). Styles use this to skip
+     * decoration on grid (cheaper rendering) while still recolouring it.
+     */
+    grid?: boolean;
+}
+export interface PolygonShape extends ShapeBase {
+    type: "polygon";
+    /** Flat list of [x0, y0, x1, y1, …]. Closed implicitly. */
+    vertices: number[];
+    paint: Paint;
+}
+export interface TextShape extends ShapeBase {
+    type: "text";
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+    fontFamily?: string;
+    fontStyle?: string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    align?: "left" | "center" | "right";
+    verticalAlign?: "top" | "middle" | "bottom";
+    width?: number;
+    height?: number;
+    /** Fraction of fontSize from top to baseline (SVG positioning). */
+    baselineRatio?: number;
+    /** Konva offsetY ratio applied to centre text vertically. */
+    konvaCorrectionRatio?: number;
+    /** Optional 2D affine transform [a, b, c, d, e, f]. */
+    transform?: [number, number, number, number, number, number];
+}
+export interface ImageShape extends ShapeBase {
+    type: "image";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    src: string;
+    /** Optional 2D affine transform [a, b, c, d, e, f]. */
+    transform?: [number, number, number, number, number, number];
+}
+/**
+ * Positional container. Children render relative to {@link x}, {@link y}.
+ * Groups can nest; the final world position of a child is the cumulative
+ * sum of group origins plus the child's own offset.
+ */
+export interface GroupShape extends ShapeBase {
+    type: "group";
+    x: number;
+    y: number;
+    children: Shape[];
+}
+export type Shape = RectShape | CircleShape | LineShape | PolygonShape | TextShape | ImageShape | GroupShape;
+/** Axis-aligned bounding box in world space. */
+export interface Bbox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+/**
+ * Full output of one {@link ScenePipeline} build pass. Consumers slice this by
+ * layer and feed the relevant subset into culling, hit-testing, and rendering.
+ */
+export interface SceneIR {
+    /** All shapes for the current scene, world-space. */
+    shapes: Shape[];
+    /** Optional pre-computed bbox for whole-scene framing. */
+    bounds?: Bbox;
+}

package/dist/scene/SpecialExitStyle.d.ts

@@ -0,0 +1,37 @@
+import { Settings } from '../types/Settings';
+export type SpecialExitLineData = {
+    points: number[];
+    stroke: string;
+    strokeWidth: number;
+    dash?: number[];
+};
+export type SpecialExitArrowData = {
+    tipX: number;
+    tipY: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+};
+export type SpecialExitDoorData = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    stroke: string;
+    strokeWidth: number;
+};
+export type SpecialExitData = {
+    /** Exit name (customLines key) — short or long form as stored on the room. */
+    dir: string;
+    line: SpecialExitLineData;
+    arrow?: SpecialExitArrowData;
+    door?: SpecialExitDoorData;
+};
+/**
+ * Compute draw data for all custom lines (special exits) on a room.
+ */
+export declare function computeSpecialExits(room: MapData.Room, settings: Settings, colorOverride?: string): SpecialExitData[];

package/dist/scene/StubStyle.d.ts

@@ -0,0 +1,15 @@
+import { Settings } from '../types/Settings';
+export type StubData = {
+    roomId: number;
+    direction: MapData.direction;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    stroke: string;
+    strokeWidth: number;
+};
+/**
+ * Compute stub line data for a room's one-way exit indicators.
+ */
+export declare function computeStubs(room: MapData.Room, settings: Settings, colorOverride?: string): StubData[];

package/dist/scene/elements/ExitLayout.d.ts

@@ -0,0 +1,22 @@
+import { IMapReader } from '../../reader/MapReader';
+import { Settings } from '../../types/Settings';
+import { ExitDrawData } from '../../ExitRenderer';
+import { GroupShape, HitInfo, PolygonShape } from '../Shape';
+/**
+ * Pure layout for a room's inner exits (up/down/in/out triangles). Returns
+ * polygon shapes in coordinates relative to the room's top-left, ready to
+ * drop into the room's GroupShape as children.
+ */
+export declare function layoutInnerExits(room: MapData.Room, mapReader: IMapReader, settings: Settings): PolygonShape[];
+/**
+ * Pure layout for a single inter-room link exit, given its computed
+ * {@link ExitDrawData}. Returns a {@link GroupShape} at the world origin;
+ * the active {@link Style} (e.g. Isometric) is responsible for any
+ * cube-base offset on the link layer.
+ *
+ * `hit` is optional — callers that want the exit to participate in
+ * hit-testing pass an {@link HitInfo} carrying the exit identity (a, b,
+ * aDir, bDir). Omitted for one-off exit shapes used in current-room
+ * overlays where the exit isn't independently pickable.
+ */
+export declare function layoutLinkExit(data: ExitDrawData, hit?: HitInfo): GroupShape;

package/dist/scene/elements/GridLayout.d.ts

@@ -0,0 +1,24 @@
+import { Settings, ViewportBounds } from '../../types/Settings';
+import { LineShape } from '../Shape';
+export interface GridLayoutOptions {
+    /** Inverse coordinate transform (rendered → Cartesian) for warped pipelines. */
+    inverseTransform?: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Pure layout for the background grid. Returns the line shapes that span the
+ * given viewport bounds with one extra grid step of buffer on every edge.
+ *
+ * Returns an empty array when grids are disabled. Caching is the caller's
+ * responsibility (the previous renderer cached by snapped bounds).
+ */
+export declare function layoutGrid(viewportBounds: ViewportBounds, settings: Settings, options?: GridLayoutOptions): LineShape[];
+/** Snapped bounds — for cache-key comparison by callers. */
+export declare function gridSnappedBounds(viewportBounds: ViewportBounds, settings: Settings, options?: GridLayoutOptions): {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+} | null;

package/dist/scene/elements/LabelLayout.d.ts

@@ -0,0 +1,11 @@
+import { Settings } from '../../types/Settings';
+import { GroupShape } from '../Shape';
+/**
+ * Pure layout for one user-defined label. Returns a {@link GroupShape}, or
+ * `null` when the label is suppressed by `labelRenderMode === "none"`.
+ *
+ * `noScaling` labels are anchored at (X, -Y) with content at (0,0) so the
+ * RecordingLayerNode can cancel out stage zoom for those groups only — the
+ * group origin / child origin split mirrors that requirement.
+ */
+export declare function labelToShape(label: MapData.Label, settings: Settings): GroupShape | null;

package/dist/scene/elements/OverlayLayout.d.ts

@@ -0,0 +1,14 @@
+import { HighlightData, PathOverlayData, PositionMarkerData } from '../OverlayStyle';
+import { Shape } from '../Shape';
+/**
+ * Build a highlight ring around a room. Circle rooms get a single dashed
+ * stroke; rectangular variants get four independent dashed lines (wrapped in
+ * a group) so the corner dashes line up cleanly — each side's dash pattern
+ * starts fresh at the corner instead of wrapping continuously around the
+ * perimeter (same approach as the backend renderer).
+ */
+export declare function highlightToShape(data: HighlightData): Shape;
+/** Build the player-position marker. */
+export declare function positionMarkerToShape(data: PositionMarkerData): Shape;
+/** Build a path overlay: outline + inner colour line per segment, plus directional triangles. */
+export declare function pathToShapes(data: PathOverlayData): Shape[];

package/dist/scene/elements/RoomLayout.d.ts

@@ -0,0 +1,19 @@
+import { IMapReader } from '../../reader/MapReader';
+import { Settings } from '../../types/Settings';
+import { GroupShape } from '../Shape';
+export interface RoomLayoutOptions {
+    /** Override stroke colour (used for highlighted rooms). */
+    strokeOverride?: string;
+    /**
+     * Whether the active style preserves a flat coordinate space. Iso-style
+     * pipelines pass `false` to suppress concentric rings (which would render
+     * as flat diamonds outside the cube footprint).
+     */
+    flatPipeline: boolean;
+}
+/**
+ * Pure layout for a single room. Returns a {@link GroupShape} positioned at
+ * the room's top-left, with rect/circle/line/text children for the body,
+ * border, emboss, and symbol.
+ */
+export declare function layoutRoom(room: MapData.Room, mapReader: IMapReader, settings: Settings, options: RoomLayoutOptions): GroupShape;

package/dist/scene/elements/SpecialExitLayout.d.ts

@@ -0,0 +1,19 @@
+import { Settings } from '../../types/Settings';
+import { SpecialExitData } from '../SpecialExitStyle';
+import { GroupShape } from '../Shape';
+export interface SpecialExitLayoutOptions {
+    /** Stroke override (used by highlighted-room overlays). */
+    colorOverride?: string;
+}
+/**
+ * Build a {@link GroupShape} for a single already-computed special-exit
+ * record. Lets callers compute the data once (e.g. ScenePipeline records
+ * `drawnSpecialExits` for hit-testing) and reuse it for layout.
+ */
+export declare function specialExitToShape(se: SpecialExitData, roomId: number): GroupShape;
+/**
+ * Pure layout for a room's custom-line special exits. Returns one
+ * {@link GroupShape} per special exit at the world origin; the active
+ * {@link Style} applies any depth offset for the link layer.
+ */
+export declare function layoutSpecialExits(room: MapData.Room, settings: Settings, options?: SpecialExitLayoutOptions): GroupShape[];

package/dist/scene/elements/StubLayout.d.ts

@@ -0,0 +1,19 @@
+import { Settings } from '../../types/Settings';
+import { StubData } from '../StubStyle';
+import { GroupShape } from '../Shape';
+export interface StubLayoutOptions {
+    /** Stroke override (used by highlighted-room overlays). */
+    colorOverride?: string;
+}
+/**
+ * Build a {@link GroupShape} for a single already-computed stub. Lets callers
+ * compute the data once and reuse it for both layout and hit-testing records.
+ */
+export declare function stubToShape(stub: StubData): GroupShape;
+/**
+ * Pure layout for a room's stub indicators (the short lines for each entry
+ * in `room.stubs`). Returns one {@link GroupShape} per stub at the world
+ * origin; the active {@link Style} applies any depth offset for the link
+ * layer.
+ */
+export declare function layoutStubs(room: MapData.Room, settings: Settings, options?: StubLayoutOptions): GroupShape[];

package/dist/style/Style.d.ts

@@ -0,0 +1,60 @@
+import { Shape } from '../scene/Shape';
+/** Per-frame context passed to style transforms. */
+export interface StyleContext {
+    /** Camera scale (BASE_SCALE * zoom). */
+    scale: number;
+    /** Active room size in world units (for jitter / depth tuning). */
+    roomSize: number;
+}
+export interface Style {
+    /**
+     * Transform one shape into one or more shapes. Implementations should be
+     * pure: same input + context → same output. Group children are walked by
+     * the caller (the pipeline / a wrapper); transforms see leaf shapes and
+     * group shapes as-is.
+     */
+    transform(shape: Shape, ctx: StyleContext): Shape | Shape[];
+    /**
+     * Optional world-space → scene-space coordinate map for styles that warp
+     * coordinates (e.g. Isometric). When set, {@link HitTester} and
+     * {@link Camera} use the inverse to translate clicks back to map space.
+     */
+    worldToScene?(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+    /** Inverse of {@link worldToScene}. */
+    sceneToWorld?(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+}
+/** Identity style — passes shapes through unchanged. */
+export declare const identityStyle: Style;
+/**
+ * Compose a chain of styles into a single style. Shapes flow **left → right**:
+ * the leftmost style transforms first, the rightmost transforms last and gets
+ * the final say on the emitted shapes.
+ *
+ * Order matters in two ways:
+ *
+ * 1. **Shape-changing styles must come before styles that depend on the new
+ *    geometry.** {@link sketchyShapeStyle} converts rect/circle into polygon,
+ *    and {@link isometricShapeStyle} only extrudes rect/circle into cubes — so
+ *    Iso must run before Sketchy or the cubes never form.
+ * 2. **Paint-rewriting styles overwrite earlier paint choices.** Put the style
+ *    whose colour palette you want on screen *last*: in
+ *    `compose(Sketchy(...), Parchment)` Parchment recolours Sketchy's pencil
+ *    fills/strokes into the parchment palette; reverse the order and Sketchy
+ *    repaints over Parchment's choices.
+ *
+ * Example — isometric parchment cubes with hand-drawn wobble:
+ * ```ts
+ * compose(
+ *     Isometric({depth, rotation}),         // rects → cube-face polygons
+ *     Sketchy({jitter, color: '#4a3728'}),  // wobble each polygon
+ *     Parchment,                            // recolour to parchment palette
+ * );
+ * ```
+ */
+export declare function compose(...styles: Style[]): Style;

package/dist/style/applyStyle.d.ts

@@ -0,0 +1,3 @@
+import { Shape } from '../scene/Shape';
+import { Style, StyleContext } from './Style';
+export declare function applyStyleToShapes(shapes: Shape[], style: Style, ctx: StyleContext): Shape[];

package/dist/style/index.d.ts

@@ -0,0 +1,21 @@
+import { Style } from './Style';
+import { SketchyOptions } from './shape/SketchyStyle';
+import { IsometricOptions, IsometricRotation } from './shape/IsometricStyle';
+export { compose, identityStyle } from './Style';
+export type { Style, StyleContext } from './Style';
+export { applyStyleToShapes } from './applyStyle';
+/** Warm sepia / old-parchment palette. */
+export declare const Parchment: Style;
+/** Technical blueprint aesthetic — white lines on deep blue. */
+export declare const Blueprint: Style;
+/** Cyberpunk / neon aesthetic — glowing outlines on dark background. */
+export declare const Neon: Style;
+/** Hand-drawn pencil wobble. */
+export declare function Sketchy(options: SketchyOptions): Style;
+/** 2:1 isometric projection with optional cube depth. */
+export declare function Isometric(options?: IsometricOptions): Style;
+/** Construction-site hazard aesthetic — safety yellow on asphalt, orange exits. */
+export declare const Construction: Style;
+/** Sci-fi / space-exploration aesthetic — holographic cyan glow on void black. */
+export declare const SciFi: Style;
+export type { SketchyOptions, IsometricOptions, IsometricRotation };

package/dist/style/shape/BlueprintStyle.d.ts

@@ -0,0 +1,11 @@
+import { Style } from '../Style';
+/**
+ * Technical blueprint aesthetic as a {@link Style} — white lines on deep blue.
+ *
+ * - Fills are mapped through a luminance-based blue gradient (deep blue →
+ *   lighter blue) so environment differences stay visible.
+ * - Strokes become light cyan-white.
+ * - Text uses near-white blue for legibility.
+ * - Images and groups pass through unchanged.
+ */
+export declare const blueprintShapeStyle: Style;

package/dist/style/shape/ConstructionStyle.d.ts

@@ -0,0 +1,17 @@
+import { Style } from '../Style';
+/**
+ * Construction-site hazard aesthetic as a {@link Style}.
+ *
+ * Rect rooms get diagonal yellow/black stripes: the rect is rendered as a
+ * dark asphalt base, then yellow stripe polygons (clipped to the room bounds
+ * via Sutherland-Hodgman) are emitted on top, then the black border is drawn
+ * last so room edges stay crisp.  The stripe period scales with `roomSize`
+ * so markings look consistent across zoom levels and room-size settings.
+ *
+ * Other shape types:
+ * - Circles use a luminance-mapped gradient (asphalt → safety yellow).
+ * - Exit lines and polygon arrows become safety orange (#FF6600).
+ * - Text uses safety yellow.
+ * - Images and groups pass through unchanged.
+ */
+export declare const constructionShapeStyle: Style;

package/dist/style/shape/IsometricStyle.d.ts

@@ -0,0 +1,32 @@
+import { Style } from '../Style';
+export type IsometricRotation = number;
+export interface IsometricOptions {
+    /** Cube side face height. Defaults to 0.18. */
+    depth?: number;
+    /** Rotation angle in degrees. Defaults to 0. */
+    rotation?: IsometricRotation;
+}
+/**
+ * 2:1 isometric projection as a {@link Style}.
+ *
+ * - Rectangles → diamond (rhombus) polygons. Dashed rects decompose to four
+ *   dashed line shapes (one per edge). With `depth > 0` and a fill, rooms gain
+ *   right + left side faces (darker shades of the fill) drawn beneath the top
+ *   diamond plus six outline edges, producing a 3D cube look.
+ * - Circles → ellipse polygons (32 segments). Dashed circles decompose to
+ *   line segments. With `depth > 0` and a fill, the lower half extrudes into
+ *   left + right side faces.
+ * - Lines / polygons / grid lines have their coordinates projected.
+ * - Text / images keep their position and gain an affine `transform` field
+ *   that maps their bounding box to the iso parallelogram (text stays
+ *   upright; readers consume `transform` directly).
+ * - Group origins are projected; children are projected separately. Because
+ *   iso is linear, `iso(g) + iso(c) === iso(g + c)`, so the final positions
+ *   line up exactly.
+ *
+ * Provides `worldToScene` / `sceneToWorld` so `HitTester` and `Camera` can
+ * round-trip clicks through the projection. Link-layer groups (exits,
+ * special exits, stubs) are shifted down by the cube depth in render space
+ * so connectors attach at the cube base instead of the top face.
+ */
+export declare function isometricShapeStyle(options?: IsometricOptions): Style;

package/dist/style/shape/NeonStyle.d.ts

@@ -0,0 +1,17 @@
+import { Style } from '../Style';
+/**
+ * Cyberpunk / neon aesthetic as a {@link Style} — glowing coloured outlines
+ * on a dark background.
+ *
+ * - Fills become very dark with a subtle tint of the original hue.
+ * - Strokes become bright neon (hue-preserved, saturation/lightness boosted).
+ * - A glow effect is added for stroked rect / circle / line shapes by emitting
+ *   an extra wider translucent shape **before** the main one, so callers see
+ *   `[glow, main]` (the order in which they should be rendered).
+ * - Polygons get the neon repaint without a glow pass — same as the legacy
+ *   decorator, since polygons in the pipeline are inner-exit triangles and
+ *   exit arrowheads where a glow halo reads as visual noise.
+ * - Text uses bright cyan-green.
+ * - Images and groups pass through unchanged.
+ */
+export declare const neonShapeStyle: Style;

package/dist/style/shape/ParchmentStyle.d.ts

@@ -0,0 +1,13 @@
+import { Style } from '../Style';
+/**
+ * Warm sepia / old-parchment palette as a {@link Style}.
+ *
+ * - Fills are mapped through a luminance-based parchment gradient
+ *   (dark brown → light parchment) so different environment colours stay
+ *   visually distinct while keeping the aged-paper look.
+ * - Strokes become dark ink brown.
+ * - Text uses a very dark brown for legibility.
+ * - Images and groups pass through unchanged (the caller walks group
+ *   children separately).
+ */
+export declare const parchmentShapeStyle: Style;

package/dist/style/shape/SciFiStyle.d.ts

@@ -0,0 +1,16 @@
+import { Style } from '../Style';
+/**
+ * Sci-fi / space-exploration aesthetic as a {@link Style}.
+ *
+ * - Fills preserve the original room hue (so area colours stay distinct) but
+ *   are pushed to a fixed dark lightness and moderate saturation, giving each
+ *   zone a deep-space tinted look. Achromatic rooms default to cyan.
+ * - Room borders use electric cyan (#00C8FF) with a wide translucent glow halo,
+ *   giving the holographic-display bloom effect.
+ * - Exit lines and arrow polygons use targeting green-cyan (#00FFAA) with a
+ *   glow pass, evoking radar / navigation overlays.
+ * - Grid lines are rendered as a barely-visible dark tint — no glow.
+ * - Text uses near-white blue for crisp legibility on dark fills.
+ * - Images and groups pass through unchanged.
+ */
+export declare const scifiShapeStyle: Style;

package/dist/style/shape/SketchyStyle.d.ts

@@ -0,0 +1,22 @@
+import { Style } from '../Style';
+export interface SketchyOptions {
+    /** Jitter amount in map units (e.g. 0.015). */
+    jitter: number;
+    /** Pencil colour for all strokes/fills (e.g. `#444444`). */
+    color: string;
+}
+/**
+ * Hand-drawn pencil wobble as a {@link Style}. Subdivides edges into wobbly
+ * segments with seeded perpendicular jitter, so re-renders produce the same
+ * pattern.
+ *
+ * - Rectangles → wobbly polygons (paper-white fill on parchment, pencil stroke).
+ *   Rounded-corner rectangles render as a paper-white fill rect plus a wobbly
+ *   polygon outline, so the corners stay rounded but the silhouette wobbles.
+ * - Circles → wobbly 24-segment polygons.
+ * - Lines → wobbled polylines.
+ * - Polygons → wobbled edge subdivisions.
+ * - Text → repainted in pencil colour.
+ * - Images and groups pass through unchanged.
+ */
+export declare function sketchyShapeStyle(options: SketchyOptions): Style;

package/dist/style/shape/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shape-based {@link Style} implementations — geometry transformers per the
+ * {@link Style} interface in `../Style.ts`. Each style takes a {@link Shape}
+ * and returns one or more transformed shapes; no backend coupling.
+ *
+ * Usage:
+ * ```ts
+ * import {compose} from "../Style";
+ * import {parchmentShapeStyle, sketchyShapeStyle} from "./shape";
+ *
+ * const style = compose(parchmentShapeStyle, sketchyShapeStyle({
+ *     jitter: 0.012,
+ *     color: '#4a3728',
+ * }));
+ * ```
+ */
+export { parchmentShapeStyle } from './ParchmentStyle';
+export { blueprintShapeStyle } from './BlueprintStyle';
+export { neonShapeStyle } from './NeonStyle';
+export { sketchyShapeStyle } from './SketchyStyle';
+export type { SketchyOptions } from './SketchyStyle';
+export { isometricShapeStyle } from './IsometricStyle';
+export type { IsometricOptions, IsometricRotation } from './IsometricStyle';
+export { constructionShapeStyle } from './ConstructionStyle';
+export { scifiShapeStyle } from './SciFiStyle';

package/dist/style/shape/paintMap.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared colour-parsing + paint-rewriting helpers used by the shape-based
+ * Style implementations (Parchment, Blueprint, Neon).
+ *
+ * The old BaseStyle decorator versions in `../ParchmentStyle.ts`,
+ * `../BlueprintStyle.ts`, and `../NeonStyle.ts` keep their own copies for
+ * now; they're deleted in step 11.
+ */
+export interface ParsedRgb {
+    r: number;
+    g: number;
+    b: number;
+    /** 0..1 alpha — defaults to 1 when not present. */
+    a: number;
+}
+/**
+ * Parse a colour string in `rgb(r, g, b)`, `rgba(r, g, b, a)`, or
+ * `#rrggbb` form. Returns `null` for anything else (named colours,
+ * `hsl(...)`, etc.) so callers can fall back to a default.
+ */
+export declare function parseRgb(color: string): ParsedRgb | null;
+/** Format an `rgb(r, g, b)` or `rgba(r, g, b, a)` string. */
+export declare function formatRgb(r: number, g: number, b: number, a?: number): string;
+/** Perceived luminance in [0, 1] using ITU-R BT.601 weights. */
+export declare function luminance(c: ParsedRgb): number;

package/dist/style/shape/wobble.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Hand-drawn wobble math used by the shape-based SketchyStyle.
+ *
+ * Identical algorithms to `../SketchyStyle.ts` so cross-style snapshots
+ * stay byte-identical between old and new pipelines. When step 11 deletes
+ * the legacy decorator, this module becomes the single source of truth.
+ */
+/** Simple seeded LCG. Returns values in `[0, 1)`. */
+export declare function createRng(seed: number): () => number;
+/** Hash a set of numeric values into a stable integer seed. */
+export declare function hashCoords(...values: number[]): number;
+/**
+ * Subdivide a straight segment into several sub-segments with slight
+ * perpendicular displacement, producing a hand-drawn wobble.
+ */
+export declare function wobbleSegment(x1: number, y1: number, x2: number, y2: number, jitter: number, rng: () => number): number[];
+/** Wobble an open polyline. */
+export declare function wobblePolyline(points: number[], jitter: number, rng: () => number): number[];
+/** Convert a rectangle to a closed wobbly polygon. */
+export declare function wobbleRect(x: number, y: number, w: number, h: number, jitter: number, rng: () => number): number[];
+/** Convert a circle to a wobbly polygon with slight radius variation. */
+export declare function wobbleCircle(cx: number, cy: number, radius: number, jitter: number, rng: () => number): number[];
+/** Wobble a closed polygon by subdividing each edge. */
+export declare function wobblePolygonEdges(vertices: number[], jitter: number, rng: () => number): number[];