shardlight 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShardLight contributors
+
+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

@@ -0,0 +1,328 @@
+# shardlight
+
+[![CI](https://github.com/jukrapopk/shardlight/actions/workflows/ci.yml/badge.svg)](https://github.com/jukrapopk/shardlight/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/shardlight.svg)](https://www.npmjs.com/package/shardlight)
+[![license](https://img.shields.io/npm/l/shardlight.svg)](./LICENSE)
+[![demo](https://img.shields.io/badge/demo-live-ffb454)](https://jukrapopk.github.io/shardlight/)
+
+Layered **shard** lens-flare lights that render the same in normal 2D React (DOM),
+[three.js](https://threejs.org) and [React Three Fiber](https://docs.pmnd.rs/react-three-fiber).
+
+A light is an ordered list of _shards_ (glows, rays, streak bundles, halos). Shards that
+share a motion channel are baked into one image, then animated — scale, opacity and rotation —
+with no re-rendering.
+
+![shardlight presets: star, sun, sparkle, starburst, ember](https://raw.githubusercontent.com/jukrapopk/shardlight/main/assets/demo.png)
+
+- **One light, three targets.** The same config renders to `<img>`, to three.js planes, and
+  to R3F meshes, and looks identical everywhere.
+- **Easy by default.** `<ShardLight preset="star" />` draws a light; swap the preset, or start
+  from nothing.
+- **Tunable at every level.** Preset → shards → per-shard motion → channel effects → per-frame
+  values → CSS variables. Change one shard, or drive the whole light.
+- **Declarative or imperative.** Describe lights as JSX / JSON, or drive them per frame from state,
+  a ref, or CSS — without re-baking.
+- **Extensible without forking.** New shard kinds, effects and presets plug in through public
+  registries (and augmentable types). The built-ins are registered the same way.
+- **Data first.** Every light is a plain, versioned JSON config; JSX compiles to it.
+
+## Install
+
+```bash
+npm install shardlight
+```
+
+`react`, `react-dom`, `three` and `@react-three/fiber` are **optional peers** — install only
+the ones a target needs. The DOM entry never loads three.js; the three.js entry never loads
+React.
+
+## Usage
+
+### 2D React (DOM) — `shardlight/react`
+
+```tsx
+import { ShardLight, Shard, Glow, Rays, Halo } from 'shardlight/react';
+
+<ShardLight preset="star" size={320} />
+<ShardLight preset="sun" size={320} />
+
+<ShardLight preset="star" size={320} flicker>
+  <Shard id="beam" strength={0.9} size={1.1} />   {/* tweak a preset shard */}
+  <Shard id="ring" visible={false} />             {/* hide one */}
+  <Shard id="glint" kind="fan" count={5} size={0.25} channel="glint" /> {/* add one */}
+</ShardLight>
+```
+
+`flicker` and `collapse` are shorthands for those effects. Omit `preset` (or pass `preset={null}`)
+to start empty and build a light purely from `<Shard>` children.
+
+Animate from CSS variables, or imperatively through a ref — never through React props:
+
+```tsx
+const ref = useRef<ShardLightHandle>(null);
+ref.current?.set({ channels: { rays: { scale: 1.3, rotation: 20 } } });
+ref.current?.setChannel('rays', { scale: 1.3 });
+```
+
+See [Control](#control) for every level you can change.
+
+#### Effects
+
+Five built-in effects:
+
+| Effect | Params (defaults) | Does |
+|---|---|---|
+| `pulse` | `amount` 0.1, `speed` 1, `channels` `['main']` | Scales a channel in and out |
+| `flicker` | `amount` 0.15, `speed` 1, `channels` all | Wobbles a channel's brightness |
+| `spin` | `speed` 0.1 turns/s, `phase` 0, `channels` `['main']` | Turns a channel |
+| `hover` | `scale` 1.15, `opacity` 1, `rotate` 0, `spin` 0, `channels` `['main']` | Reacts while hovered |
+| `collapse` | `scale` 0, `opacity` 1, `channels` all, `trigger` click | Implodes on click (`click` toggles, `once` stays, `none` = manual) |
+
+`flicker` and `collapse` are also shorthand props:
+
+```tsx
+<ShardLight preset="ember" size={320} flicker={{ amount: 0.35 }} />
+<ShardLight preset="star" size={320} collapse />                      {/* click toggles */}
+<ShardLight preset="star" size={320} collapse={{ trigger: 'once' }} /> {/* click collapses once */}
+```
+
+`collapse={{ trigger: 'none' }}` leaves the light's click alone so you can drive it yourself —
+`ref.current?.setCollapsed(true)`, `toggleCollapsed()`, or `set({ collapse: 0..1 })` — and tie it to
+your own state. `once` collapses and stays; `click` (the default) toggles.
+
+`spin`, `hover` and `collapse` also sit directly on a shard, so a preset can carry its own defaults:
+
+```tsx
+<ShardLight preset="star" size={320}>
+  <Shard id="beam" spin={0.08} />                             {/* turns on its own */}
+  <Shard id="hotspot" hover={{ scale: 1.6, opacity: 1.4 }} /> {/* reacts to pointer-over */}
+  <Shard id="ring" hover={{ spin: 0.3 }} />                    {/* spins up while hovered */}
+  <Shard id="glint" kind="fan" count={5} collapse />           {/* implodes on click */}
+</ShardLight>
+```
+
+A shard with `spin`, `hover` or `collapse` is moved to its own channel, so it never drags the
+shards it was baked with. `spin` is `turns/second` (negative reverses). `hover` scales / fades /
+turns the shard as the pointer sits over the light, eased in and out; add `spin` to keep turning
+while hovered and hold that angle after. `collapse` scales / fades it away when the light is
+clicked, eased in and out. Both are whole-light; drive them by hand with `ref.current?.setHover(…)`
+and `ref.current?.setCollapsed(…)`.
+
+Every effect is also plain config, so a preset (or you) can list them on any channel:
+
+```ts
+effects={[
+  { type: 'spin', channels: ['rays'], speed: 0.05 },
+  { type: 'hover', channels: ['body'], scale: 1.2, spin: 0.1 },
+  { type: 'flicker', amount: 0.2, channels: ['*'] },
+  { type: 'collapse', scale: 0.2, opacity: 0, channels: ['*'] },
+]}
+```
+
+The five built-in presets ship effect-free, so a preset stays still until you give it motion.
+
+### three.js — `shardlight/three`
+
+```ts
+import { createShardLight } from 'shardlight/three';
+
+const light = createShardLight({ preset: 'sun', size: 0.6 });
+scene.add(light.object);
+
+// per frame: no re-bake, just transforms and opacity
+light.set({ channels: { rays: { scale: 1.2 } }, opacity: 0.8 });
+light.setHover(true); // eases the light's `hover` shards in
+light.toggleCollapsed(); // or setCollapsed(true) to implode
+
+light.update({ shards: [{ id: 'beam', strength: 1 }] }); // re-bakes only what changed
+light.dispose();
+```
+
+### React Three Fiber — `shardlight/r3f`
+
+```tsx
+import { ShardLightMesh, Shard } from 'shardlight/r3f';
+
+<ShardLightMesh ref={light} preset="sun" size={0.4} position={[0, 1, -2]} flicker>
+  <Shard id="ring" visible={false} />
+</ShardLightMesh>;
+
+// pointer-over eases `hover` shards in and clicks collapse — automatically
+light.current?.setHover(false);
+light.current?.setCollapsed(true);
+```
+
+### Headless core — `shardlight`
+
+Framework-free: config, kinds, presets, effects, baking and cache. Every adapter wraps
+`createLightModel()`.
+
+```ts
+import { createLightModel, resolveConfig, migrateConfig, prewarm } from 'shardlight';
+
+const model = createLightModel({
+  preset: 'star',        // a name, a config, or `null` (start empty)
+  config,                // optional partial ShardLightConfig merged over the preset
+  shards,                // optional per-shard overrides
+  effects,               // optional effects
+  resolution: 1024,
+  rayScale: 1,           // thins every ray
+  accepts: ['bitmap'],   // 'url' | 'bitmap' | 'canvas'
+  reducedMotion: false,  // pauses auto effects
+  hoverEase: 0.25,       // seconds; 0 snaps
+  collapseEase: 0.3,
+});
+
+model.subscribe((layers) => {
+  /* one image per layer: add / replace / remove host objects */
+});
+model.onFrame((values) => {
+  /* channel scale / opacity / rotation, plus the eased `hover` and `collapse` */
+});
+
+model.set({ channels: { rays: { scale: 1.2 } }, opacity: 0.8 }); // per frame
+model.setChannel('rays', { rotation: 15 });
+model.setHover(true);
+model.setCollapsed(false);
+model.toggleCollapsed();
+
+await model.ready;               // every layer baked
+model.update({ preset: 'sun' }); // re-resolves, re-bakes only what changed
+model.resolved;                  // the current ResolvedLight
+model.layers;                    // the current host layers
+model.dispose();
+```
+
+## Control
+
+Everything below animates without re-baking. Only changing a shard — its kind, params or colour —
+bakes again, and only the layers that changed.
+
+**Presets.** Start from a built-in, your own config object, or nothing:
+
+```tsx
+<ShardLight preset="sun" />
+<ShardLight preset={myConfig} />
+<ShardLight />   {/* empty: build it from <Shard> children */}
+```
+
+**Shards.** Override, hide or add any shard by `id` — no deep merge:
+
+```tsx
+<ShardLight preset="star">
+  <Shard id="beam" strength={0.9} size={1.1} />             {/* tweak a preset shard */}
+  <Shard id="ring" visible={false} />                       {/* hide one */}
+  <Shard id="glint" kind="fan" count={5} channel="glint" /> {/* add one */}
+</ShardLight>
+```
+
+**Per-shard motion.** `spin`, `hover` and `collapse` sit on a shard (see [Effects](#effects)); each
+gets its own channel so it moves independently of what it was baked with.
+
+**Channel values.** Scale / opacity / rotation per channel, statically or per frame:
+
+```tsx
+<ShardLight channels={{ rays: { scale: 1.2, rotation: 15 } }} />
+ref.current?.setChannel('rays', { opacity: 0.5 });
+```
+
+**Imperative / per-frame.** The DOM and R3F refs, and the three controller, expose:
+
+```ts
+set({ channels, opacity, hover, collapse });          // per-frame values
+setChannel(channel, { scale, opacity, rotation });
+setHover(bool); setCollapsed(bool); toggleCollapsed();
+ready;   // Promise that resolves once every layer is baked
+model;   // the headless LightModel
+```
+
+**CSS variables (DOM).** The light writes these on its root, so CSS, WAAPI, GSAP or Framer Motion
+can drive it with no JS per frame:
+
+```
+--shardlight-<channel>-scale      (default 1)
+--shardlight-<channel>-opacity    (default 1)
+--shardlight-<channel>-rotation   (default 0deg)
+--shardlight-opacity              (whole light)
+```
+
+```css
+.badge:hover { --shardlight-rays-scale: 1.3; --shardlight-rays-rotation: 15deg; }
+```
+
+**Render options.** `resolution` (`'auto'` = rendered size × DPR) and `rayScale` at the adapter;
+`baker`, `accepts`, `reducedMotion`, `hoverEase` and `collapseEase` on the model.
+
+**Data first.** Every light is a versioned `ShardLightConfig`: save and load it as JSON,
+`migrateConfig()` old saves, and `prewarm()` a config's layers before first paint.
+
+## Extending
+
+New kinds, effects and presets register like the built-ins, so they work in every target:
+
+```ts
+import {
+  star,
+  defineShardKind, registerShardKind,
+  defineEffect, registerEffect,
+  definePreset, registerPreset,
+} from 'shardlight';
+import { createShardComponent } from 'shardlight/react';
+
+// a new shard kind — `params` drives defaults, validation and typed props
+const dots = defineShardKind({
+  kind: 'dots',
+  label: 'Ring of dots',
+  params: { count: { type: 'number', default: 12, min: 1, max: 64, step: 1 } },
+  draw(ctx, p, env) { /* the context is centred, rotated and coloured for you */ },
+});
+registerShardKind(dots);
+
+// a new effect — a pure function of time over the frame values
+const sway = defineEffect({
+  name: 'sway',
+  params: { amount: { type: 'number', default: 0.4, min: 0, max: 1 } },
+  apply(t, p, out) { out.channel('rays').rotation += p.amount * 30 * Math.sin(t); },
+});
+registerEffect(sway);
+
+// a preset is just a config, and can carry its own motion
+registerPreset('star-spin', {
+  ...star,
+  effects: [{ type: 'spin', channels: ['rays'], speed: 0.05 }],
+});
+
+// typed components for a kind, in either React entry
+const Dots = createShardComponent(dots);
+<ShardLight preset="star"><Dots id="crown" count={8} /></ShardLight>
+```
+
+`ShardKinds`, `ShardPresets` and `ChannelValues` are augmentable, so downstream kinds and presets
+are typed too:
+
+```ts
+declare module 'shardlight' {
+  interface ShardKinds { dots: ParamsOf<typeof dots> }
+}
+```
+
+## Adapter contract
+
+`shardlight/testing` exports the contract suite (`runAdapterContract`, `createFakeBaker`,
+`waitFor`) that any adapter — including a third-party one — can run against itself.
+
+## Testing
+
+```bash
+pnpm test           # Vitest unit tests (config, model, effects, three adapter)
+pnpm test:visual    # Playwright: golden PNGs + cross-target parity (Chromium)
+```
+
+The visual tests render every preset in real headless Chromium through all three targets,
+compare against golden PNGs in `tests/visual/__screenshots__`, and check parity between
+`<ShardLight>`, `createShardLight()` and `<ShardLightMesh>`. Regenerate goldens with
+`pnpm test:visual:update` after an intentional look change.
+
+## License
+
+MIT

package/dist/baker-BmlWqsXG.d.ts

@@ -0,0 +1,290 @@
+/**
+ * The config model. A ShardLight is an ordered list of shards, each a
+ * flat set of that kind's parameters. Flat means no nested `shape: {}` objects,
+ * so overriding one field never needs a deep merge, and config keys match the
+ * component props one to one.
+ *
+ * The `Base*` interfaces are the built-ins. The public, augmentable interfaces
+ * (`ShardKinds`, `ShardPresets`, `ChannelValues`) are declared on the package
+ * entry so downstream code can extend them with `declare module 'shardlight'`.
+ */
+interface BlobParams {
+    /** Peak brightness. Above 1 saturates the middle. */
+    strength: number;
+    /** Fade-out radius, as a fraction of the light's half-edge. */
+    size: number;
+    /** Share of the radius held at full brightness before the falloff. */
+    hardness: number;
+    /** Curve past `hardness`. */
+    falloff: number;
+    /** Horizontal ÷ vertical stretch. */
+    aspect: number;
+    /** Direction of the stretch, degrees. */
+    angle: number;
+    /** Composite blur, px at a 1024 bake. */
+    softness: number;
+    /** Uneven brightness around the centre. */
+    variance: number;
+}
+interface FanParams {
+    strength: number;
+    /** Ray length, from `inner` out. */
+    size: number;
+    /** Number of rays; 2 = one line through the centre. */
+    count: number;
+    /** First ray's direction, degrees. */
+    angle: number;
+    /** Measure `angle` from that fan shard's `angle` instead of from 0. */
+    relativeTo?: string;
+    /** Angular wander per ray, as a share of half the gap between rays. */
+    jitter: number;
+    /** Where rays start, from the centre. */
+    inner: number;
+    /** Per-ray length / brightness / width randomness. */
+    variance: number;
+    /** Width at the root, px at a 1024 bake (ray-scaled). */
+    width: number;
+    /** 0 = constant width, 1 = pointed tip. */
+    taper: number;
+    /** Brightness along the length. */
+    falloff: number;
+    /** Distance from the root over which the ray ramps in. */
+    fadeIn: number;
+    /** Composite blur, px (ray-scaled). */
+    softness: number;
+}
+interface ClusterParams {
+    /** Number of bundles. */
+    clusters: number;
+    /** Rays per bundle. */
+    perCluster: number;
+    /** Angular width of a bundle, degrees. */
+    spread: number;
+    /** Where rays start; each ray also varies by ±variance/2. */
+    inner: number;
+    strength: number;
+    size: number;
+    angle: number;
+    relativeTo?: string;
+    variance: number;
+    width: number;
+    taper: number;
+    falloff: number;
+    fadeIn: number;
+    softness: number;
+}
+interface HaloParams {
+    strength: number;
+    /** Radius of the brightest line. */
+    size: number;
+    /** Ring thickness, as a fraction of the half-edge. */
+    width: number;
+    /** Edge curve across the thickness. */
+    falloff: number;
+    /** Composite blur, px. */
+    softness: number;
+    /** Uneven brightness around the ring. */
+    variance: number;
+}
+/** Built-in kinds. Extend the public `ShardKinds` on the entry to add one. */
+interface BaseShardKinds {
+    blob: BlobParams;
+    fan: FanParams;
+    clusters: ClusterParams;
+    halo: HaloParams;
+}
+/** Built-in presets. Extend the public `ShardPresets` on the entry to add one. */
+interface BaseShardPresets {
+    star: true;
+    sun: true;
+    sparkle: true;
+    starburst: true;
+    ember: true;
+}
+type ShardBlend = 'add' | 'screen';
+interface ShardSpin {
+    /** Turns per second; negative reverses. */
+    speed: number;
+    /** Starting angle, degrees. Default 0. */
+    phase?: number;
+}
+interface ShardHover {
+    /** Scale multiplier at full hover. Default 1 (no change). */
+    scale?: number;
+    /** Opacity multiplier at full hover. Default 1 (no change). */
+    opacity?: number;
+    /** Degrees added at full hover. Default 0. */
+    rotate?: number;
+    /** Turns/second banked while hovered; negative reverses. Default 0. */
+    spin?: number;
+}
+interface ShardCollapse {
+    /** Scale at full collapse. Default 0 (implodes). */
+    scale?: number;
+    /** Opacity at full collapse. Default 1 (keeps its brightness). */
+    opacity?: number;
+}
+interface ShardBase {
+    /** Stable name: seeds its randomness, target of overrides. */
+    id: string;
+    /** Any registered kind. */
+    kind: string;
+    /** Default true. */
+    visible?: boolean;
+    /** Motion channel it animates with; default 'main'. */
+    channel?: string;
+    /**
+     * Turns this shard continuously. `number` = turns/second; object = `{ speed, phase }`.
+     * A shard that spins is given its own animation channel, so it turns
+     * independently of the shards baked with it.
+     */
+    spin?: number | ShardSpin;
+    /**
+     * Reacts while the pointer is over the light. `true` = a small default bump;
+     * object = `{ scale, opacity, rotate }` at full hover. Eased in and out.
+     */
+    hover?: boolean | ShardHover;
+    /**
+     * Collapses when the light is clicked. `true` = implodes to nothing;
+     * object = `{ scale, opacity }` at full collapse. Click again to expand.
+     */
+    collapse?: boolean | ShardCollapse;
+    /** Default 'add'. */
+    blend?: ShardBlend;
+    /** Overrides the light's colour for this shard only. */
+    color?: string;
+    /** Overrides the light's seed for this shard only. */
+    seed?: number;
+}
+/** A shard's spin, with defaults filled in. */
+interface ResolvedSpin {
+    speed: number;
+    phase: number;
+}
+/** A shard's hover response, with defaults filled in. */
+interface ResolvedHover {
+    scale: number;
+    opacity: number;
+    rotate: number;
+    spin: number;
+}
+/** A shard's collapse response, with defaults filled in. */
+interface ResolvedCollapse {
+    scale: number;
+    opacity: number;
+}
+/** A full shard: `kind` required, params optional (kind defaults fill the rest). */
+type ShardConfig = {
+    [K in keyof BaseShardKinds]: ShardBase & {
+        kind: K;
+    } & Partial<BaseShardKinds[K]>;
+}[keyof BaseShardKinds] & {
+    relativeTo?: string;
+};
+/**
+ * What overrides accept (`<Shard>` props, the `shards` option,
+ * `config.shards`): either a full shard, or a partial one whose `id` names a
+ * shard already in the preset. A partial one omits `kind` and inherits it.
+ */
+type ShardInput = ShardConfig | ({
+    id: string;
+    kind?: string;
+} & Partial<Omit<ShardBase, 'id' | 'kind'>> & Record<string, unknown>);
+interface EffectConfig {
+    type: string;
+    [param: string]: unknown;
+}
+interface ShardLightConfig {
+    /** Schema version. */
+    version: 1;
+    /** Default '#FFFFFF'. */
+    color: string;
+    /** Degrees; turns the whole light. Default 0. */
+    rotation: number;
+    /** Default 1. */
+    seed: number;
+    /** Drawn in order (additive, so order only matters for 'screen'). */
+    shards: ShardConfig[];
+    /** Optional animations. */
+    effects?: EffectConfig[];
+}
+/** A preset is a plain ShardLightConfig. Built-ins: star, sun, sparkle, starburst, ember. */
+type BuiltInPresetName = keyof BaseShardPresets;
+type Preset = string | ShardLightConfig;
+interface ResolvedShard {
+    id: string;
+    kind: string;
+    visible: boolean;
+    channel: string;
+    blend: ShardBlend;
+    /** Resolved colour (shard override or the light's). */
+    color: string;
+    /** Resolved seed (shard override or the light's). */
+    seed: number;
+    /** Present when the shard turns. */
+    spin?: ResolvedSpin;
+    /** Present when the shard reacts to hover. */
+    hover?: ResolvedHover;
+    /** Present when the shard collapses on click. */
+    collapse?: ResolvedCollapse;
+    /** Kind defaults filled in and clamped. */
+    params: Record<string, unknown>;
+}
+interface ResolvedLight {
+    version: 1;
+    color: string;
+    rotation: number;
+    seed: number;
+    shards: ResolvedShard[];
+    effects: EffectConfig[];
+}
+interface ResolvedLayer {
+    /** Content hash of the resolved shards plus light-wide bake inputs. */
+    key: string;
+    /** Stable while the layer exists: `${channel}|${blend}`. */
+    id: string;
+    channel: string;
+    blend: ShardBlend;
+    shards: ResolvedShard[];
+    color: string;
+    rotation: number;
+    seed: number;
+}
+
+/**
+ * What a baked layer can become. Adapters say which types they
+ * accept, and the model asks the baker for a compatible one: DOM takes `url`,
+ * three takes `bitmap` or `canvas`.
+ */
+type LayerSource = {
+    type: 'url';
+    url: string;
+} | {
+    type: 'bitmap';
+    bitmap: ImageBitmap;
+} | {
+    type: 'canvas';
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+};
+interface BakeOptions {
+    resolution: number;
+    rayScale: number;
+    accept: LayerSource['type'][];
+}
+/**
+ * Baking sits behind this interface, so where and how it happens can change
+ * without touching kinds or adapters. The baker's `id` is part of the cache key.
+ */
+interface Baker {
+    id: string;
+    bake(layer: ResolvedLayer, opts: BakeOptions, signal: AbortSignal): Promise<LayerSource>;
+}
+/**
+ * Thrown when a 2D context is unavailable (canvas memory cap). Treat it as a
+ * non-fatal "try again later": the result is left uncached.
+ */
+declare class NullContextError extends Error {
+    constructor();
+}
+
+export { type Baker as B, type ClusterParams as C, type EffectConfig as E, type FanParams as F, type HaloParams as H, type LayerSource as L, NullContextError as N, type Preset as P, type ResolvedLight as R, type ShardInput as S, type ShardLightConfig as a, type ShardConfig as b, type ShardBase as c, type ResolvedLayer as d, type BaseShardKinds as e, type BaseShardPresets as f, type BakeOptions as g, type BlobParams as h, type BuiltInPresetName as i, type ResolvedCollapse as j, type ResolvedHover as k, type ResolvedShard as l, type ResolvedSpin as m, type ShardBlend as n, type ShardCollapse as o, type ShardHover as p, type ShardSpin as q };