@orbytes/astrolab 0.3.0

package/src/shell/index.json.ts

@@ -0,0 +1,12 @@
+// <subpath>/index.json — the lab index as a static file, injected by ../../index.mjs and
+// prerendered like every other lab route. Every story: id, URLs, files, tier/section/version, live
+// slot, used-by, tags, summary — so worker briefs and scripts can read this instead of globbing.
+import type { APIRoute } from "astro";
+import { buildLabIndex } from "./lab-index";
+
+export const prerender = true;
+
+export const GET: APIRoute = () =>
+  new Response(`${JSON.stringify(buildLabIndex(), null, 2)}\n`, {
+    headers: { "Content-Type": "application/json; charset=utf-8" },
+  });

package/src/shell/lab-index.ts

@@ -0,0 +1,344 @@
+// The lab index — every story in the lab, classified, with its live status derived from the site's
+// pages. Built server-side at build time (or per request in dev); consumed by Home.astro, the
+// folder pages (Browse.astro) and the static <subpath>/index.json endpoint.
+//
+// Data sources, in order of authority:
+//   1. `virtual:astrobook/story-modules.mjs` — Astrobook's own module list (id, name, directory,
+//      importPath, stories). Using it rather than re-deriving ids means our URLs can never drift
+//      from the ones Astrobook actually routes.
+//   2. `virtual:astrobook/global-config.mjs` — the dashboard and story base paths.
+//   3. `virtual:orbytes-lab/config.mjs` — the lab's own resolved options (../../index.mjs).
+//   4. src/pages/**.astro, through live-files.mjs — what is live, and on which page. Derived,
+//      never declared. Every page is walked, not just the home page (2026-09-06), so the pill
+//      survives a multi-page site.
+//   5. <directory>/responsive.json, through marks.mjs — the hand-set responsive marks. The one
+//      thing here that is ticked rather than derived, because approval cannot be read from code.
+//   6. The stories files themselves — the component they render, the leading comment (summary)
+//      and, through import.meta.glob, the default export's optional `meta.tags`.
+//
+// Classification is by Astrobook `directory` (relative to its `directory` option):
+//   <tier>/<Section>/<Version>/…   tier = first segment; for the tier holding the RESPONSIVE role
+//                                  (by default "sections") the second segment is the section and
+//                                  the third the version (V1, V2 …).
+// Anything else classifies as tier = first segment with no section or version.
+/// <reference path="../types/virtual.d.ts" />
+/// <reference path="../../virtual.d.ts" />
+import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { root } from "astro:config/server";
+import storyModules from "virtual:astrobook/story-modules.mjs";
+import astrobookConfig from "virtual:astrobook/global-config.mjs";
+import {
+  defaultImports,
+  liveComponentFiles,
+  storyComponentFile,
+  toRepoRelative,
+} from "./live-files.mjs";
+import { readResponsive } from "./marks.mjs";
+import labConfig from "virtual:orbytes-lab/config.mjs";
+
+/**
+ * The deployed lab — the real minified build, which a dev server is not. Null when the consumer
+ * set no `stagingUrl`, and then nothing links to it.
+ */
+export const STAGING_URL = labConfig.stagingUrl;
+
+/** One page a component is mounted on. */
+export interface LiveMount {
+  /** the page's route: "/" for src/pages/index.astro, "/about" for about.astro */
+  page: string;
+  /** 1-based position among the components that page mounts */
+  slot: number;
+  /** how many components that page mounts */
+  of: number;
+}
+
+export interface LabItem {
+  storyId: string;
+  storyName: string;
+  moduleId: string;
+  moduleName: string;
+  /** repo-relative, e.g. src/lab/explorations/KeycapButton.stories.ts */
+  moduleFile: string;
+  /** the .astro the stories file imports as `component`, repo-relative */
+  componentFile: string | null;
+  directory: string;
+  tier: string;
+  section: string | null;
+  version: string | null;
+  dashboardUrl: string;
+  storyUrl: string;
+  /** the primary mount — the home page's when there is one, else the first page in route order */
+  live: { slot: number; of: number } | null;
+  /** the page `live` is on ("/" for the home page); null when the component is not mounted */
+  livePage: string | null;
+  /** every page that mounts it — one entry on a normal site, more for shared chrome */
+  liveOn: LiveMount[];
+  /** section versions only (tier "sections"); null everywhere the mark does not apply */
+  responsive: { done: boolean; approved: boolean } | null;
+  /** the same story on the deployed lab; null when no `stagingUrl` is configured */
+  stagingUrl: string | null;
+  /** vscode://file/<absolute path> to the component; null in a build — the link is dev-only */
+  editorUrl: string | null;
+  /** repo-relative files of LIVE section components that import this item's componentFile */
+  usedBy: string[];
+  tags: string[];
+  summary: string | null;
+}
+
+export interface LabFolder {
+  /** e.g. sections/Section02Manifesto */
+  path: string;
+  name: string;
+  /** child folder paths */
+  children: string[];
+  /** storyIds directly inside */
+  items: string[];
+  /** distinct live component files anywhere under this folder */
+  liveCount: number;
+  /** section versions under this folder: how many are marked responsive, out of how many */
+  responsive: { done: number; of: number };
+}
+
+export interface LabIndex {
+  generatedAt: string;
+  items: LabItem[];
+  folders: LabFolder[];
+  live: { file: string; page: string; slot: number; of: number }[];
+}
+
+// Only for the optional `meta` on a story module's default export — Astrobook ignores unknown
+// keys, so `export default { component, meta: { tags: [...] } }` is legal and this is where it is
+// read. Keys are root-relative (`/src/...`); the pattern covers both the current and target trees.
+const storyExports = import.meta.glob("/src/**/*.stories.ts", { eager: true }) as Record<
+  string,
+  { default?: { meta?: { tags?: unknown } } } | undefined
+>;
+
+const tagsOf = (moduleFile: string): string[] => {
+  const tags = storyExports[`/${moduleFile}`]?.default?.meta?.tags;
+  return Array.isArray(tags) ? tags.filter((t): t is string => typeof t === "string") : [];
+};
+
+// First sentence of the leading `//` comment block — the stories files already open with the
+// section's provenance in one line, so that is the summary.
+const summaryOf = (rootDir: string, moduleFile: string): string | null => {
+  const abs = path.join(rootDir, moduleFile);
+  if (!existsSync(abs)) return null;
+  const lines: string[] = [];
+  for (const line of readFileSync(abs, "utf8").split(/\r?\n/)) {
+    if (!line.startsWith("//")) break;
+    lines.push(line.replace(/^\/\/\s?/, ""));
+  }
+  const text = lines.join(" ").replace(/\s+/g, " ").trim();
+  if (!text) return null;
+  const sentence = text.match(/^(.+?[.!?])(?:\s|$)/);
+  return (sentence ? sentence[1] : text).trim();
+};
+
+const classify = (directory: string) => {
+  const parts = directory ? directory.split("/") : [];
+  const tier = parts[0] ?? "";
+  const sectional = tier === "sections";
+  return {
+    tier,
+    section: sectional && parts[1] ? parts[1] : null,
+    version: sectional && parts[2] ? parts[2] : null,
+  };
+};
+
+const trimSlash = (p: string) => p.replace(/\/+$/, "");
+
+/** The lab's URL base (`/lab`), read from Astrobook's resolved config rather than repeated. */
+export const labBase = trimSlash(astrobookConfig.astrobookBase);
+
+export function buildLabIndex(): LabIndex {
+  const rootDir = fileURLToPath(root);
+  const live = liveComponentFiles(rootDir);
+
+  // Mounts grouped by component file, in page order — [0] is the primary one (the home page's,
+  // when the component is on the home page, because sitePages() puts it first).
+  const mountsByFile = new Map<string, LiveMount[]>();
+  for (const mount of live) {
+    const list = mountsByFile.get(mount.file) ?? [];
+    list.push({ page: mount.page, slot: mount.slot, of: mount.of });
+    mountsByFile.set(mount.file, list);
+  }
+
+  // usedBy: one level down from every live component — whatever it imports is "used by" it.
+  const usedBy = new Map<string, string[]>();
+  for (const file of mountsByFile.keys()) {
+    for (const imp of defaultImports(rootDir, file)) {
+      if (imp.file === file) continue;
+      const list = usedBy.get(imp.file) ?? [];
+      if (!list.includes(file)) list.push(file);
+      usedBy.set(imp.file, list);
+    }
+  }
+
+  const marks = readResponsive(rootDir, labConfig);
+  const doneMarks = new Set(marks.done);
+  const approvedMarks = new Set(marks.approved);
+
+  // The editor link is a local absolute path, so it is built in dev only — both because a staging
+  // visitor has no such file and because the path has no business in a deployed page. VS Code's
+  // form is `vscode://file/<absolute path>`, and on POSIX the absolute path supplies that slash.
+  const editorUrlOf = (file: string | null): string | null => {
+    if (!import.meta.env.DEV || !file) return null;
+    const abs = path.join(rootDir, file).split(path.sep).join("/");
+    return `vscode://file${abs.startsWith("/") ? "" : "/"}${abs}`;
+  };
+
+  const dashboardBase = trimSlash(astrobookConfig.dashboardBase);
+  const storyBase = trimSlash(astrobookConfig.storyBase);
+
+  const items: LabItem[] = [];
+  for (const mod of storyModules) {
+    const moduleFile = toRepoRelative(rootDir, mod.importPath);
+    const componentFile = storyComponentFile(rootDir, moduleFile);
+    const liveOn = (componentFile ? mountsByFile.get(componentFile) : undefined) ?? [];
+    const primary = liveOn[0];
+    const { tier, section, version } = classify(mod.directory);
+    const tags = tagsOf(moduleFile);
+    const summary = summaryOf(rootDir, moduleFile);
+    const responsive = RESPONSIVE_DIR && moduleFile.startsWith(RESPONSIVE_DIR)
+      ? { done: doneMarks.has(moduleFile), approved: approvedMarks.has(moduleFile) }
+      : null;
+    for (const story of mod.stories) {
+      items.push({
+        storyId: story.id,
+        storyName: story.name,
+        moduleId: mod.id,
+        moduleName: mod.name,
+        moduleFile,
+        componentFile,
+        directory: mod.directory,
+        tier,
+        section,
+        version,
+        dashboardUrl: `${dashboardBase}/${story.id}`,
+        storyUrl: `${storyBase}/${story.id}`,
+        live: primary ? { slot: primary.slot, of: primary.of } : null,
+        livePage: primary ? primary.page : null,
+        liveOn,
+        responsive,
+        stagingUrl: STAGING_URL ? `${STAGING_URL}${storyBase}/${story.id}` : null,
+        editorUrl: editorUrlOf(componentFile ?? moduleFile),
+        usedBy: componentFile ? (usedBy.get(componentFile) ?? []) : [],
+        tags,
+        summary,
+      });
+    }
+  }
+
+  // Folders: every prefix of every module directory. Items sit in their own directory; liveCount
+  // counts distinct live component files anywhere beneath, so a section folder reads "1 live"
+  // however many stories its live version has.
+  const folders = new Map<string, LabFolder>();
+  const ensure = (folderPath: string): LabFolder => {
+    let folder = folders.get(folderPath);
+    if (!folder) {
+      folder = {
+        path: folderPath,
+        name: folderPath.split("/").pop() ?? folderPath,
+        children: [],
+        items: [],
+        liveCount: 0,
+        responsive: { done: 0, of: 0 },
+      };
+      folders.set(folderPath, folder);
+      const parent = folderPath.includes("/") ? folderPath.slice(0, folderPath.lastIndexOf("/")) : "";
+      if (parent) {
+        const parentFolder = ensure(parent);
+        if (!parentFolder.children.includes(folderPath)) parentFolder.children.push(folderPath);
+      }
+    }
+    return folder;
+  };
+  for (const item of items) {
+    if (!item.directory) continue;
+    ensure(item.directory).items.push(item.storyId);
+  }
+  for (const folder of folders.values()) {
+    const under = items.filter(
+      (item) => item.directory === folder.path || item.directory.startsWith(`${folder.path}/`),
+    );
+    folder.liveCount = new Set(
+      under.filter((item) => item.live && item.componentFile).map((item) => item.componentFile),
+    ).size;
+    // Counted per version, not per story: two stories of one section version are one version.
+    const versions = new Map(
+      under.filter((item) => item.responsive).map((item) => [item.moduleFile, item.responsive!]),
+    );
+    folder.responsive = {
+      done: [...versions.values()].filter((mark) => mark.done).length,
+      of: versions.size,
+    };
+    folder.children.sort();
+  }
+
+  return {
+    generatedAt: new Date().toISOString(),
+    items,
+    folders: [...folders.values()].sort((a, b) => a.path.localeCompare(b.path)),
+    live,
+  };
+}
+
+// Shared helpers for the pages, so the ordering and grouping logic lives once.
+
+/** The configured tiers first, in the order they were declared; anything else after, alphabetically. */
+export const TIER_ORDER = labConfig.tiers.map((tier) => tier.id);
+
+const TIER_LABELS = new Map(labConfig.tiers.map((tier) => [tier.id, tier.label]));
+
+/** The directory the responsive marks are restricted to, e.g. `src/lab/sections/`. */
+const RESPONSIVE_DIR = labConfig.responsiveDir;
+
+export const sortTiers = (tiers: string[]): string[] =>
+  [...tiers].sort((a, b) => {
+    const ia = TIER_ORDER.indexOf(a);
+    const ib = TIER_ORDER.indexOf(b);
+    if (ia !== -1 || ib !== -1) return (ia === -1 ? 99 : ia) - (ib === -1 ? 99 : ib);
+    return a.localeCompare(b);
+  });
+
+export const tierLabel = (tier: string): string =>
+  TIER_LABELS.get(tier) ?? (tier ? tier.charAt(0).toUpperCase() + tier.slice(1) : "Root");
+
+/** Distinct live component files among a set of items. */
+export const liveCountOf = (items: LabItem[]): number =>
+  new Set(items.filter((i) => i.live && i.componentFile).map((i) => i.componentFile)).size;
+
+/** Items directly in a folder or anywhere beneath it. */
+export const itemsUnder = (index: LabIndex, folderPath: string): LabItem[] =>
+  index.items.filter(
+    (item) => item.directory === folderPath || item.directory.startsWith(`${folderPath}/`),
+  );
+
+/**
+ * The live pill's text. A single-page site reads exactly as it always did — `live · slot 3 of 12`
+ * — and only a page that is not the home page names itself: `live · /about, slot 3`.
+ * The sidebar script in LabHead.astro carries the same three lines; keep the two in step.
+ */
+export const livePillText = (item: LabItem): string | null => {
+  if (!item.live) return null;
+  return item.livePage && item.livePage !== "/"
+    ? `live · ${item.livePage}, slot ${item.live.slot}`
+    : `live · slot ${item.live.slot} of ${item.live.of}`;
+};
+
+/** Every page a component is live on, one per line — the live pill's tooltip. */
+export const liveTitle = (item: LabItem): string | undefined =>
+  item.liveOn.length > 1
+    ? item.liveOn.map((mount) => `${mount.page} · slot ${mount.slot} of ${mount.of}`).join("\n")
+    : undefined;
+
+/**
+ * Whether a story renders at page width — in a thumbnail and as the viewport's default frame.
+ * True for the tier holding the RESPONSIVE role: a section version is the one thing in the lab
+ * that IS a page, which is also why it is the only thing a responsive mark applies to.
+ */
+export const isSectionLike = (item: LabItem): boolean =>
+  labConfig.sectionsTier !== null && item.tier === labConfig.sectionsTier;

package/src/shell/lab-params.ts

@@ -0,0 +1,245 @@
+/* =============================================================================================
+   lab-params.ts — the parameters-panel contract for the viewport lab.
+
+   Consumers import it as `@orbytes/astrolab/params`; inside this package the path is relative.
+
+   WHAT THIS IS. Ruled 2026-09-06: on request, a component bakes in a parameters panel to
+   configure it, and the configurator for those parameters is installed right below the top
+   navigation in the viewport lab for each section. The panel is available only to the specific
+   sections or experiments that have parameters to change. For most sections, it is not needed
+   at all.
+
+   So: a component that has something to tune DECLARES it here and renders nothing. The panel is
+   drawn by the viewport lab's chrome (./Viewport.astro), between the top bar and the
+   stage — and only there. The same story at <subpath>/stories/<id> (the bare render) and on the
+   dashboard shows no panel at all, because nothing in this module touches the DOM.
+
+   HOW IT FITS TOGETHER. This module runs INSIDE the story document (the iframe). It keeps the
+   registered groups on `window.__labParams` and announces each one with a `lab:params` event on
+   that same window. The viewport page is the story's parent and same-origin, so it reads that
+   array directly, builds the UI, and calls the group's own `apply()` across the frame boundary.
+   Nothing is serialised, nothing is posted: `values` is one live object that both sides hold.
+
+   PERSISTENCE. Values are stored per group in `localStorage` under `lab-params:<group id>`, so a
+   tuning survives a reload and a prev/next walk. Reset clears the key and restores the declared
+   defaults. `storageKey` overrides the key and exists for ONE reason — a panel inheriting values
+   from an older hand-rolled panel (the four glass libraries keep their `glass96:<lib>` keys so
+   saved tunings survive the port). New panels leave it out.
+
+   ---------------------------------------------------------------------------------------------
+   ADDING A PANEL TO A COMPONENT — the whole recipe.
+
+   In the component's client `<script>`, set up whatever the panel drives FIRST, or declare that
+   state with `let` before you register: `registerLabParams` calls `apply()` once, synchronously,
+   with the restored values, so `apply` must tolerate being called before the thing it configures
+   exists. Then:
+
+       import { registerLabParams } from "@orbytes/astrolab/params";
+
+       const shader = document.querySelector<HTMLCanvasElement>(".hero__shader");
+       let uniforms: Uniforms | null = null;          // filled in below; apply() tolerates null
+
+       const panel = registerLabParams({
+         id: "hero-shader",                            // stable — it is the storage key
+         title: "hero shader",
+         source: { href: "https://github.com/x/y", label: "github.com/x/y · MIT" },
+         note: "Uniforms are read every frame; nothing here is on the live page.",
+         controls: [
+           { kind: "range",  id: "speed", label: "Speed", min: 0, max: 4, step: 0.05, value: 1, unit: "×" },
+           { kind: "toggle", id: "grain", label: "Grain", value: true },
+           { kind: "select", id: "blend", label: "Blend", value: "screen",
+             options: [{ value: "screen", label: "screen" }, { value: "add", label: "add" }] },
+           { kind: "color",  id: "tint",  label: "Tint",  value: "#2e5bff" },
+         ],
+         apply(values) {
+           if (!uniforms) return;
+           uniforms.speed = Number(values.speed);
+           uniforms.grain = Boolean(values.grain);
+           uniforms.blend = String(values.blend);
+           uniforms.tint = String(values.tint);
+         },
+       });
+
+       const v = panel.values;      // LIVE — mutated in place, so a render loop can hold it
+       uniforms = start(shader, v);
+       panel.status("WebGL2 · 0.8 ms/frame");   // one line under the controls, push it whenever
+
+   That is all. Reset, Copy settings, the collapse chevron, the readouts, the units and the
+   storage are the panel's job, not the component's.
+   ============================================================================================= */
+
+export type LabParamValue = number | boolean | string;
+export type LabParamValues = Record<string, LabParamValue>;
+
+/** One row of the panel. `id` is the key in `values`; `note` is shown on hover. */
+export type LabParamControl =
+  | {
+      kind: "range";
+      id: string;
+      label: string;
+      min: number;
+      max: number;
+      step?: number;
+      value: number;
+      unit?: string;
+      note?: string;
+    }
+  | { kind: "toggle"; id: string; label: string; value: boolean; note?: string }
+  | {
+      kind: "select";
+      id: string;
+      label: string;
+      value: string;
+      options: { value: string; label: string }[];
+      note?: string;
+    }
+  | { kind: "color"; id: string; label: string; value: string; note?: string };
+
+export interface LabParamGroup {
+  /** Stable, and the localStorage key suffix. One group per thing being tuned. */
+  id: string;
+  /** Shown as the group's heading — "liquid-glass-webgl". */
+  title: string;
+  /** Where the code came from and under what terms — rendered as a link. */
+  source?: { href: string; label: string };
+  /** One line of explanation, shown small beside the title. */
+  note?: string;
+  controls: LabParamControl[];
+  /**
+   * Push the whole value set into whatever it configures. Called once at registration with the
+   * restored values, and again on every change — so it must be idempotent and must survive being
+   * called before the component has finished setting itself up.
+   */
+  apply(values: LabParamValues): void;
+  /** Extra work when Reset is pressed — the values are already back at their defaults. */
+  reset?(): void;
+  /**
+   * LEGACY ONLY. Overrides the storage key so a panel can inherit an older panel's saved values.
+   * New panels omit it and get `lab-params:<id>`.
+   */
+  storageKey?: string;
+}
+
+/** What the component gets back. */
+export interface LabParamHandle {
+  /** Live values — mutated in place, so a render loop can just hold the reference. */
+  values: LabParamValues;
+  /** One line of status under the controls (WebGL state, frame cost, an error). */
+  status(text: string): void;
+}
+
+/** What the viewport panel consumes off `window.__labParams`. The component never needs this. */
+export interface LabParamEntry extends LabParamHandle {
+  group: LabParamGroup;
+  storageKey: string;
+  /** The declared defaults — what Reset restores. */
+  defaults: LabParamValues;
+  /** The last status pushed, so a panel built after the component started still shows it. */
+  lastStatus: string;
+  /** Set by the panel; called on every `status()`. */
+  onStatus: ((text: string) => void) | null;
+  /** Write one control, persist, and apply. */
+  set(id: string, value: LabParamValue): void;
+  /** Restore the declared defaults, clear storage, apply, and run the group's own `reset`. */
+  resetAll(): void;
+  /** The current values as pretty JSON — what "Copy settings" puts on the clipboard. */
+  json(): string;
+}
+
+declare global {
+  interface Window {
+    /** Every group registered by this document, in registration order. */
+    __labParams?: LabParamEntry[];
+  }
+  interface WindowEventMap {
+    "lab:params": CustomEvent<LabParamEntry>;
+  }
+}
+
+const STORE_PREFIX = "lab-params:";
+
+const readStore = (key: string): Record<string, unknown> => {
+  try {
+    const raw = JSON.parse(localStorage.getItem(key) || "{}");
+    return raw && typeof raw === "object" ? (raw as Record<string, unknown>) : {};
+  } catch {
+    return {};
+  }
+};
+
+/** A stored value is only accepted if it still fits the control that declared it. */
+const coerce = (control: LabParamControl, raw: unknown): LabParamValue | undefined => {
+  switch (control.kind) {
+    case "range": {
+      if (typeof raw !== "number" || !Number.isFinite(raw)) return undefined;
+      return Math.min(control.max, Math.max(control.min, raw));
+    }
+    case "toggle":
+      return typeof raw === "boolean" ? raw : undefined;
+    case "select":
+      return typeof raw === "string" && control.options.some((o) => o.value === raw) ? raw : undefined;
+    case "color":
+      return typeof raw === "string" && /^#[0-9a-f]{3,8}$/i.test(raw) ? raw : undefined;
+  }
+};
+
+export function registerLabParams(group: LabParamGroup): LabParamHandle {
+  const storageKey = group.storageKey ?? `${STORE_PREFIX}${group.id}`;
+
+  const defaults: LabParamValues = {};
+  for (const control of group.controls) defaults[control.id] = control.value;
+
+  const values: LabParamValues = { ...defaults };
+  const stored = readStore(storageKey);
+  for (const control of group.controls) {
+    const restored = coerce(control, stored[control.id]);
+    if (restored !== undefined) values[control.id] = restored;
+  }
+
+  const save = () => {
+    try {
+      localStorage.setItem(storageKey, JSON.stringify(values));
+    } catch {
+      /* private mode, quota — the panel still works for the session */
+    }
+  };
+
+  const entry: LabParamEntry = {
+    group,
+    storageKey,
+    defaults,
+    values,
+    lastStatus: "",
+    onStatus: null,
+    status(text) {
+      entry.lastStatus = text;
+      entry.onStatus?.(text);
+    },
+    set(id, value) {
+      values[id] = value;
+      save();
+      group.apply(values);
+    },
+    resetAll() {
+      Object.assign(values, defaults);
+      try {
+        localStorage.removeItem(storageKey);
+      } catch {
+        /* ignore */
+      }
+      group.apply(values);
+      group.reset?.();
+    },
+    json() {
+      return JSON.stringify(values, null, 2);
+    },
+  };
+
+  (window.__labParams ??= []).push(entry);
+  // Apply the restored values before anyone is told the group exists, so the first frame a
+  // viewer sees is already the tuning that was saved.
+  group.apply(values);
+  window.dispatchEvent(new CustomEvent("lab:params", { detail: entry }));
+
+  return entry;
+}