@ggts-sh/svelte 0.43.0

package/dist/geoms/GeomStep.svelte

@@ -0,0 +1,12 @@
+<!-- GENERATED by scripts/gen-geom-children.ts — do not edit. Run: bun run geom:children:gen -->
+<script lang="ts">
+  import type { DataInput, StepParams, StepLayerInput } from "@ggts-sh/spec";
+
+  import { createGeomLayer } from "./factory.svelte.js";
+
+  const props: StepParams &
+    Omit<StepLayerInput, "geom" | "params" | "data"> & {
+      data?: DataInput | readonly Record<string, unknown>[];
+    } = $props();
+  createGeomLayer("step", () => props);
+</script>

package/dist/geoms/GeomStep.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { DataInput, StepParams, StepLayerInput } from "@ggts-sh/spec";
+type $$ComponentProps = StepParams & Omit<StepLayerInput, "geom" | "params" | "data"> & {
+    data?: DataInput | readonly Record<string, unknown>[];
+};
+declare const GeomStep: import("svelte").Component<$$ComponentProps, {}, "">;
+type GeomStep = ReturnType<typeof GeomStep>;
+export default GeomStep;

package/dist/geoms/GeomText.svelte

@@ -0,0 +1,12 @@
+<!-- GENERATED by scripts/gen-geom-children.ts — do not edit. Run: bun run geom:children:gen -->
+<script lang="ts">
+  import type { DataInput, TextParams, TextLayerInput } from "@ggts-sh/spec";
+
+  import { createGeomLayer } from "./factory.svelte.js";
+
+  const props: TextParams &
+    Omit<TextLayerInput, "geom" | "params" | "data"> & {
+      data?: DataInput | readonly Record<string, unknown>[];
+    } = $props();
+  createGeomLayer("text", () => props);
+</script>

package/dist/geoms/GeomText.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { DataInput, TextParams, TextLayerInput } from "@ggts-sh/spec";
+type $$ComponentProps = TextParams & Omit<TextLayerInput, "geom" | "params" | "data"> & {
+    data?: DataInput | readonly Record<string, unknown>[];
+};
+declare const GeomText: import("svelte").Component<$$ComponentProps, {}, "">;
+type GeomText = ReturnType<typeof GeomText>;
+export default GeomText;

package/dist/geoms/GeomTile.svelte

@@ -0,0 +1,21 @@
+<!-- GENERATED by scripts/gen-geom-children.ts — do not edit. Run: bun run geom:children:gen -->
+<script module lang="ts">
+  import { registerTile } from "@ggts-sh/core";
+
+  // Self-registration (#1420): this component's geom batch + default stat
+  // frame enter the bundle (and the core registries) only when the
+  // component itself is imported. Idempotent.
+  registerTile();
+</script>
+
+<script lang="ts">
+  import type { DataInput, TileParams, TileLayerInput } from "@ggts-sh/spec";
+
+  import { createGeomLayer } from "./factory.svelte.js";
+
+  const props: TileParams &
+    Omit<TileLayerInput, "geom" | "params" | "data"> & {
+      data?: DataInput | readonly Record<string, unknown>[];
+    } = $props();
+  createGeomLayer("tile", () => props);
+</script>

package/dist/geoms/GeomTile.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { DataInput, TileParams, TileLayerInput } from "@ggts-sh/spec";
+type $$ComponentProps = TileParams & Omit<TileLayerInput, "geom" | "params" | "data"> & {
+    data?: DataInput | readonly Record<string, unknown>[];
+};
+declare const GeomTile: import("svelte").Component<$$ComponentProps, {}, "">;
+type GeomTile = ReturnType<typeof GeomTile>;
+export default GeomTile;

package/dist/geoms/GeomViolin.svelte

@@ -0,0 +1,25 @@
+<!-- GENERATED by scripts/gen-geom-children.ts — do not edit. Run: bun run geom:children:gen -->
+<script module lang="ts">
+  import { registerViolin } from "@ggts-sh/core";
+
+  // Self-registration (#1420): this component's geom batch + default stat
+  // frame enter the bundle (and the core registries) only when the
+  // component itself is imported. Idempotent.
+  registerViolin();
+</script>
+
+<script lang="ts">
+  import type {
+    DataInput,
+    ViolinParams,
+    ViolinLayerInput,
+  } from "@ggts-sh/spec";
+
+  import { createGeomLayer } from "./factory.svelte.js";
+
+  const props: ViolinParams &
+    Omit<ViolinLayerInput, "geom" | "params" | "data"> & {
+      data?: DataInput | readonly Record<string, unknown>[];
+    } = $props();
+  createGeomLayer("violin", () => props);
+</script>

package/dist/geoms/GeomViolin.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { DataInput, ViolinParams, ViolinLayerInput } from "@ggts-sh/spec";
+type $$ComponentProps = ViolinParams & Omit<ViolinLayerInput, "geom" | "params" | "data"> & {
+    data?: DataInput | readonly Record<string, unknown>[];
+};
+declare const GeomViolin: import("svelte").Component<$$ComponentProps, {}, "">;
+type GeomViolin = ReturnType<typeof GeomViolin>;
+export default GeomViolin;

package/dist/geoms/GeomVline.svelte

@@ -0,0 +1,12 @@
+<!-- GENERATED by scripts/gen-geom-children.ts — do not edit. Run: bun run geom:children:gen -->
+<script lang="ts">
+  import type { DataInput, VlineParams, VlineLayerInput } from "@ggts-sh/spec";
+
+  import { createGeomLayer } from "./factory.svelte.js";
+
+  const props: VlineParams &
+    Omit<VlineLayerInput, "geom" | "params" | "data"> & {
+      data?: DataInput | readonly Record<string, unknown>[];
+    } = $props();
+  createGeomLayer("vline", () => props);
+</script>

package/dist/geoms/GeomVline.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { DataInput, VlineParams, VlineLayerInput } from "@ggts-sh/spec";
+type $$ComponentProps = VlineParams & Omit<VlineLayerInput, "geom" | "params" | "data"> & {
+    data?: DataInput | readonly Record<string, unknown>[];
+};
+declare const GeomVline: import("svelte").Component<$$ComponentProps, {}, "">;
+type GeomVline = ReturnType<typeof GeomVline>;
+export default GeomVline;

package/dist/geoms/factory.svelte.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Factory for declaration-only geom components (decision 0001, mechanism A).
+ *
+ * Every <GeomX> component is a thin shell: it destructures nothing, passes
+ * its live `$props()` proxy here, and this factory registers a layer
+ * descriptor whose getters read the proxy — so prop updates flow into the
+ * plot's derived spec without re-registration. Param keys come from
+ * `GEOM_PARAM_KEYS` (#1039), not a hand-copied third argument.
+ *
+ * Init-time registration only (never in $effect); inert without a <GGPlot>
+ * ancestor; unregisters on destroy (all measured in the M0a-1 spike).
+ */
+import { type AesInput, type DataInput, type GeomName, type PositionName, type PositionParams, type RenderBackend, type StatName } from "@ggts-sh/spec";
+export interface GeomProps {
+    /** Layer-level aes (bare-string shorthand allowed); merges over plot aes. */
+    aes?: AesInput;
+    /** Optional layer-local data (#589); inherits plot data when omitted. */
+    data?: DataInput | readonly Record<string, unknown>[];
+    /** Stat override (geoms with more than one stat, e.g. errorbar summary). */
+    stat?: StatName;
+    /** Position override (per-geom subset; normalize/validate enforce it). */
+    position?: PositionName;
+    /** Jitter/nudge parameters (point/text layers). */
+    positionParams?: PositionParams;
+    /** Rendering backend hint ("svg" | "canvas" | "auto"). */
+    render?: RenderBackend;
+    /**
+     * `false` excludes this layer from inspection (#1065): its marks never
+     * become tooltip, hover, or keyboard candidates. For background bands and
+     * other decoration, which otherwise capture the pointer everywhere they are
+     * painted.
+     */
+    inspect?: false;
+}
+/**
+ * Register a geom layer from a component's live props proxy (passed as an
+ * accessor so the proxy is only ever read lazily, inside the descriptor's
+ * getters). Param whitelist is `GEOM_PARAM_KEYS[geom]`; aes/stat/position/
+ * positionParams travel structurally.
+ */
+export declare function createGeomLayer(geom: GeomName, getProps: () => GeomProps): void;

package/dist/geoms/factory.svelte.js

@@ -0,0 +1,60 @@
+/**
+ * Factory for declaration-only geom components (decision 0001, mechanism A).
+ *
+ * Every <GeomX> component is a thin shell: it destructures nothing, passes
+ * its live `$props()` proxy here, and this factory registers a layer
+ * descriptor whose getters read the proxy — so prop updates flow into the
+ * plot's derived spec without re-registration. Param keys come from
+ * `GEOM_PARAM_KEYS` (#1039), not a hand-copied third argument.
+ *
+ * Init-time registration only (never in $effect); inert without a <GGPlot>
+ * ancestor; unregisters on destroy (all measured in the M0a-1 spike).
+ */
+import { GEOM_PARAM_KEYS, } from "@ggts-sh/spec";
+import { registerLayer } from "./registry.svelte.js";
+/**
+ * Register a geom layer from a component's live props proxy (passed as an
+ * accessor so the proxy is only ever read lazily, inside the descriptor's
+ * getters). Param whitelist is `GEOM_PARAM_KEYS[geom]`; aes/stat/position/
+ * positionParams travel structurally.
+ */
+export function createGeomLayer(geom, getProps) {
+    const paramKeys = GEOM_PARAM_KEYS[geom];
+    if (paramKeys === undefined) {
+        throw new Error(`createGeomLayer: no GEOM_PARAM_KEYS entry for geom "${geom}"`);
+    }
+    registerLayer({
+        geom,
+        get stat() {
+            return getProps().stat;
+        },
+        get aes() {
+            return getProps().aes;
+        },
+        get data() {
+            return getProps().data;
+        },
+        get position() {
+            return getProps().position;
+        },
+        get positionParams() {
+            return getProps().positionParams;
+        },
+        get render() {
+            return getProps().render;
+        },
+        get inspect() {
+            return getProps().inspect;
+        },
+        get params() {
+            const props = getProps();
+            const params = {};
+            for (const key of paramKeys) {
+                const value = props[key];
+                if (value !== undefined)
+                    params[key] = value;
+            }
+            return Object.keys(params).length > 0 ? params : undefined;
+        },
+    });
+}

package/dist/geoms/registry.svelte.d.ts

@@ -0,0 +1,71 @@
+export type { Layer, MarkLayerDescriptor } from "../layers/types.js";
+import type { Layer, MarkLayerDescriptor } from "../layers/types.js";
+import type { InspectCapabilityChild } from "../interaction/resolve-inspect-capability.js";
+/**
+ * Host-only interaction capabilities registered by declaration children
+ * (`<Inspect>`, later select/zoom/…). Not members of the grammar `Layer`
+ * union and never folded into PortableSpec.
+ */
+export type HostCapabilityKind = "inspect";
+/** Value bags per capability kind (extend when more children land). */
+export type HostCapabilityValue = {
+    readonly inspect: InspectCapabilityChild;
+};
+export declare class LayerRegistry {
+    #private;
+    /** Register a mark/geom descriptor (wraps as `{ kind: "mark", descriptor }`). */
+    register(descriptor: MarkLayerDescriptor): number;
+    /** Register any layer kind (mark or non-mark). Returns the entry id. */
+    registerPlotLayer(layer: Layer): number;
+    /**
+     * Register a host-only capability (inspect, later select/zoom/…).
+     * Live `value` getter is load-bearing (ADR 0001). Returns entry id.
+     */
+    registerCapability<K extends HostCapabilityKind>(kind: K, getValue: () => HostCapabilityValue[K]): number;
+    unregister(id: number): void;
+    /** Every registered layer in registration order (reactive read). */
+    get layers(): readonly Layer[];
+    /**
+     * Mark/geom descriptors only, unwrapped, in registration order.
+     * Consumers that need `.data` / `toLayerInput` must use this — not `layers`.
+     */
+    get markLayers(): readonly MarkLayerDescriptor[];
+    /**
+     * Host capability values of `kind` in registration order (reactive).
+     * Multiple entries of the same kind are all returned so resolve can last-win
+     * and multi-child diagnostics can fire.
+     *
+     * Depends on `#capabilityVersion` only — mark/grammar churn must not invalidate
+     * capability readers (see field comment).
+     */
+    capabilities<K extends HostCapabilityKind>(kind: K): readonly HostCapabilityValue[K][];
+    /**
+     * Monotonic count of successful `register` / `registerPlotLayer` /
+     * `registerCapability` calls. Unregister does not decrement. Tests use this
+     * to assert ADR 0001's zero-re-registration guarantee under live prop updates.
+     */
+    get registrationCount(): number;
+}
+/** Called by <GGPlot> during component init. */
+export declare function provideRegistry(): LayerRegistry;
+/**
+ * Read the ancestor <GGPlot> LayerRegistry, if any. Used by tests that assert
+ * ADR 0001 registrationCount under live child updates; inert outside a plot.
+ */
+export declare function getLayerRegistry(): LayerRegistry | undefined;
+/**
+ * Called by geom components during component init. Inert (no-op) when there
+ * is no <GGPlot> ancestor.
+ */
+export declare function registerLayer(descriptor: MarkLayerDescriptor): void;
+/**
+ * Register any plot layer (mark or non-mark) during component init.
+ * Inert without a <GGPlot> ancestor. Slices 2–6 use this for theme/scale/
+ * coord/facet/labs/guides/legend children; tests use it until those ship.
+ */
+export declare function registerPlotLayer(layer: Layer): void;
+/**
+ * Register a host-only capability during component init (e.g. `<Inspect>`).
+ * Inert without a <GGPlot> ancestor. Live getter over child props (ADR 0001).
+ */
+export declare function registerHostCapability<K extends HostCapabilityKind>(kind: K, getValue: () => HostCapabilityValue[K]): void;

package/dist/geoms/registry.svelte.js

@@ -0,0 +1,177 @@
+/**
+ * Layer registry for declaration-only children (decision 0001, mechanism A).
+ *
+ * Contract (all load-bearing, measured in the M0a-1 spike):
+ *  - The authoritative store is a plain NON-reactive insertion-ordered Map;
+ *    a monotonic version `$state` (distinct value per mutation) drives
+ *    reactivity. NEVER a reactive array with read-modify-write: Svelte 5
+ *    batching can lose an update when a keyed {#each} destroys one child and
+ *    creates another in the same flush.
+ *  - Children register DURING COMPONENT INIT (never in $effect) with live
+ *    getter descriptors / values over their $props, and unregister in
+ *    onDestroy.
+ *  - <GGPlot> renders `{@render children?.()}` BEFORE any registry-consuming
+ *    markup (SSR correctness depends on it).
+ *
+ * Layer kinds (#659 slice 1): the Map holds the full `Layer` union (mark +
+ * non-mark plot contributions). `markLayers` is the geom-only view used by
+ * assembly and the #609 data-identity epoch; `layers` returns every kind in
+ * registration order. Non-mark components land in later slices; tests and
+ * those components register via `registerPlotLayer`.
+ */
+import { getContext, onDestroy, setContext } from "svelte";
+let nextId = 0;
+let globalVersion = 0;
+export class LayerRegistry {
+    #byId = new Map();
+    /** Host capabilities — separate from grammar layers (never plotLayers). */
+    #capabilities = new Map();
+    /** Bumps only on mark/grammar layer register/unregister. */
+    #version = $state(0);
+    /**
+     * Bumps only on host-capability register/unregister. Kept separate from
+     * `#version` so geom mount/unmount does not re-run inspect resolve →
+     * interactionConfig diagnostics (config diagnostics re-deliver per recompute
+     * and must not fire on unrelated layer churn).
+     */
+    #capabilityVersion = $state(0);
+    /** Monotonic register count (never decrements). For ADR 0001 test assertions. */
+    #registrationCount = 0;
+    /** Register a mark/geom descriptor (wraps as `{ kind: "mark", descriptor }`). */
+    register(descriptor) {
+        return this.registerPlotLayer({ kind: "mark", descriptor });
+    }
+    /** Register any layer kind (mark or non-mark). Returns the entry id. */
+    registerPlotLayer(layer) {
+        const id = nextId++;
+        this.#byId.set(id, layer);
+        this.#registrationCount += 1;
+        this.#version = ++globalVersion;
+        return id;
+    }
+    /**
+     * Register a host-only capability (inspect, later select/zoom/…).
+     * Live `value` getter is load-bearing (ADR 0001). Returns entry id.
+     */
+    registerCapability(kind, getValue) {
+        const id = nextId++;
+        const entry = {
+            kind,
+            get value() {
+                return getValue();
+            },
+        };
+        this.#capabilities.set(id, entry);
+        this.#registrationCount += 1;
+        this.#capabilityVersion = ++globalVersion;
+        return id;
+    }
+    unregister(id) {
+        const removedLayer = this.#byId.delete(id);
+        const removedCapability = this.#capabilities.delete(id);
+        if (removedLayer)
+            this.#version = ++globalVersion;
+        if (removedCapability)
+            this.#capabilityVersion = ++globalVersion;
+    }
+    /** Every registered layer in registration order (reactive read). */
+    get layers() {
+        void this.#version; // reactive dependency; the Map itself is non-reactive
+        return [...this.#byId.values()];
+    }
+    /**
+     * Mark/geom descriptors only, unwrapped, in registration order.
+     * Consumers that need `.data` / `toLayerInput` must use this — not `layers`.
+     */
+    get markLayers() {
+        void this.#version;
+        const out = [];
+        for (const layer of this.#byId.values()) {
+            if (layer.kind === "mark")
+                out.push(layer.descriptor);
+        }
+        return out;
+    }
+    /**
+     * Host capability values of `kind` in registration order (reactive).
+     * Multiple entries of the same kind are all returned so resolve can last-win
+     * and multi-child diagnostics can fire.
+     *
+     * Depends on `#capabilityVersion` only — mark/grammar churn must not invalidate
+     * capability readers (see field comment).
+     */
+    capabilities(kind) {
+        void this.#capabilityVersion;
+        const out = [];
+        for (const entry of this.#capabilities.values()) {
+            if (entry.kind === kind) {
+                // entry is CapabilityEntry; kind narrow leaves value as the union of all
+                // capability values. Only inspect exists today so this is the inspect bag.
+                out.push(entry.value);
+            }
+        }
+        return out;
+    }
+    /**
+     * Monotonic count of successful `register` / `registerPlotLayer` /
+     * `registerCapability` calls. Unregister does not decrement. Tests use this
+     * to assert ADR 0001's zero-re-registration guarantee under live prop updates.
+     */
+    get registrationCount() {
+        return this.#registrationCount;
+    }
+}
+const KEY = Symbol("ggsvelte-layer-registry");
+/** Called by <GGPlot> during component init. */
+export function provideRegistry() {
+    const registry = new LayerRegistry();
+    setContext(KEY, registry);
+    return registry;
+}
+/**
+ * Read the ancestor <GGPlot> LayerRegistry, if any. Used by tests that assert
+ * ADR 0001 registrationCount under live child updates; inert outside a plot.
+ */
+export function getLayerRegistry() {
+    return getContext(KEY);
+}
+/**
+ * Called by geom components during component init. Inert (no-op) when there
+ * is no <GGPlot> ancestor.
+ */
+export function registerLayer(descriptor) {
+    const registry = getContext(KEY);
+    if (!registry)
+        return;
+    const id = registry.register(descriptor);
+    onDestroy(() => {
+        registry.unregister(id);
+    });
+}
+/**
+ * Register any plot layer (mark or non-mark) during component init.
+ * Inert without a <GGPlot> ancestor. Slices 2–6 use this for theme/scale/
+ * coord/facet/labs/guides/legend children; tests use it until those ship.
+ */
+export function registerPlotLayer(layer) {
+    const registry = getContext(KEY);
+    if (!registry)
+        return;
+    const id = registry.registerPlotLayer(layer);
+    onDestroy(() => {
+        registry.unregister(id);
+    });
+}
+/**
+ * Register a host-only capability during component init (e.g. `<Inspect>`).
+ * Inert without a <GGPlot> ancestor. Live getter over child props (ADR 0001).
+ */
+export function registerHostCapability(kind, getValue) {
+    const registry = getContext(KEY);
+    if (!registry)
+        return;
+    const id = registry.registerCapability(kind, getValue);
+    onDestroy(() => {
+        registry.unregister(id);
+    });
+}

package/dist/guides/GuideAxis.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+  /**
+   * <GuideAxis> — declaration-only axis-guide layer for <GGPlot> (#659 slice 6).
+   * Keys an axis guide by positional channel: `<GuideAxis channel="x"
+   * showTicks={false}/>` → `guides: { x: { type: "axis", showTicks: false } }`.
+   * Emits NO markup.
+   */
+  import { guideAxis, type AxisGuideOptions } from "@ggts-sh/spec";
+
+  import { createPlotLayer } from "../layers/plot-layer.svelte.js";
+  import { splitChannel, type PositionGuideChannel } from "./factory.svelte.js";
+
+  type Props = AxisGuideOptions & { channel: PositionGuideChannel };
+
+  const props: Props = $props();
+  createPlotLayer("guides", () => {
+    const { channel, options } = splitChannel(props);
+    return { [channel]: guideAxis(options) };
+  });
+</script>

package/dist/guides/GuideAxis.svelte.d.ts

@@ -0,0 +1,14 @@
+/**
+   * <GuideAxis> — declaration-only axis-guide layer for <GGPlot> (#659 slice 6).
+   * Keys an axis guide by positional channel: `<GuideAxis channel="x"
+   * showTicks={false}/>` → `guides: { x: { type: "axis", showTicks: false } }`.
+   * Emits NO markup.
+   */
+import { type AxisGuideOptions } from "@ggts-sh/spec";
+import { type PositionGuideChannel } from "./factory.svelte.js";
+type Props = AxisGuideOptions & {
+    channel: PositionGuideChannel;
+};
+declare const GuideAxis: import("svelte").Component<Props, {}, "">;
+type GuideAxis = ReturnType<typeof GuideAxis>;
+export default GuideAxis;

package/dist/guides/GuideColorbar.svelte

@@ -0,0 +1,22 @@
+<script lang="ts">
+  /**
+   * <GuideColorbar> — declaration-only colorbar-guide layer for <GGPlot>
+   * (#659 slice 6). Continuous-legend presentation for one aesthetic.
+   * Emits NO markup.
+   */
+  import { guideColorbar, type ColorbarGuideOptions } from "@ggts-sh/spec";
+
+  import { createPlotLayer } from "../layers/plot-layer.svelte.js";
+  import {
+    splitChannel,
+    type NonPositionGuideChannel,
+  } from "./factory.svelte.js";
+
+  type Props = ColorbarGuideOptions & { channel: NonPositionGuideChannel };
+
+  const props: Props = $props();
+  createPlotLayer("guides", () => {
+    const { channel, options } = splitChannel(props);
+    return { [channel]: guideColorbar(options) };
+  });
+</script>

package/dist/guides/GuideColorbar.svelte.d.ts

@@ -0,0 +1,13 @@
+/**
+   * <GuideColorbar> — declaration-only colorbar-guide layer for <GGPlot>
+   * (#659 slice 6). Continuous-legend presentation for one aesthetic.
+   * Emits NO markup.
+   */
+import { type ColorbarGuideOptions } from "@ggts-sh/spec";
+import { type NonPositionGuideChannel } from "./factory.svelte.js";
+type Props = ColorbarGuideOptions & {
+    channel: NonPositionGuideChannel;
+};
+declare const GuideColorbar: import("svelte").Component<Props, {}, "">;
+type GuideColorbar = ReturnType<typeof GuideColorbar>;
+export default GuideColorbar;

package/dist/guides/GuideColorsteps.svelte

@@ -0,0 +1,22 @@
+<script lang="ts">
+  /**
+   * <GuideColorsteps> — declaration-only colorsteps-guide layer for <GGPlot>
+   * (#659 slice 6). Binned-legend presentation for one aesthetic.
+   * Emits NO markup.
+   */
+  import { guideColorsteps, type ColorstepsGuideOptions } from "@ggts-sh/spec";
+
+  import { createPlotLayer } from "../layers/plot-layer.svelte.js";
+  import {
+    splitChannel,
+    type NonPositionGuideChannel,
+  } from "./factory.svelte.js";
+
+  type Props = ColorstepsGuideOptions & { channel: NonPositionGuideChannel };
+
+  const props: Props = $props();
+  createPlotLayer("guides", () => {
+    const { channel, options } = splitChannel(props);
+    return { [channel]: guideColorsteps(options) };
+  });
+</script>

package/dist/guides/GuideColorsteps.svelte.d.ts

@@ -0,0 +1,13 @@
+/**
+   * <GuideColorsteps> — declaration-only colorsteps-guide layer for <GGPlot>
+   * (#659 slice 6). Binned-legend presentation for one aesthetic.
+   * Emits NO markup.
+   */
+import { type ColorstepsGuideOptions } from "@ggts-sh/spec";
+import { type NonPositionGuideChannel } from "./factory.svelte.js";
+type Props = ColorstepsGuideOptions & {
+    channel: NonPositionGuideChannel;
+};
+declare const GuideColorsteps: import("svelte").Component<Props, {}, "">;
+type GuideColorsteps = ReturnType<typeof GuideColorsteps>;
+export default GuideColorsteps;