forgebook 0.3.3 → 0.4.1

package/dist/src/vite/lookAlikes.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Which of a project's components look like the same one.
+ *
+ * @remarks
+ * Pure. A name alone says little (every feature has a `Header`), so it takes a second sign (a telling root, shared props,
+ * the same classes) to call two alike; and a component that renders the other is built on it, which is what reuse looks
+ * like.
+ *
+ * @module
+ */
+import type { ScannedComponent } from "./componentScan.ts";
+/** Two or more components that look like one. */
+export type LookAlike = {
+    /** How sure this is: `high` has two signs beyond the name, or a name and a look. */
+    readonly confidence: "high" | "medium";
+    /** What they have in common. */
+    readonly why: string;
+    /** The components. */
+    readonly members: readonly Pick<ScannedComponent, "name" | "file" | "line">[];
+};
+/**
+ * The sign of a copy, the surest there is, so it counts twice.
+ */
+export declare const SAME_CODE = "the same code";
+/**
+ * What a component's name says it is, without the words for which of a kind it is.
+ *
+ * @param name - its name.
+ */
+export declare const stemOf: (name: string) => string;
+/**
+ * What two components have in common, each a sign they are one.
+ *
+ * @param first - one.
+ * @param second - the other.
+ */
+export declare const signsBetween: (first: ScannedComponent, second: ScannedComponent) => string[];
+/**
+ * Whether a component of a name renders by hand the element a component of that name exists for: an agent's way of
+ * rebuilding one, whatever the other's root (often a slot this cannot read) and props.
+ *
+ * @param added - the new one.
+ * @param stem - what both names say they are.
+ */
+export declare const isRebuilt: (added: ScannedComponent, stem: string) => boolean;
+/**
+ * Whether one is built on the other: reuse, not a copy.
+ *
+ * @param first - one.
+ * @param second - the other.
+ */
+export declare const isBuiltOn: (first: ScannedComponent, second: ScannedComponent) => boolean;
+/**
+ * Whether a component is one to share: a screen is one of a kind, however alike its layout.
+ *
+ * @param component - the component.
+ */
+export declare const isShareable: ({ file, name }: Pick<ScannedComponent, "file" | "name">) => boolean;
+/**
+ * The components that look like one: first by name, then by look across names. Screens are left out: each is one of a
+ * kind, however alike their layouts.
+ *
+ * @param components - every component of the project.
+ */
+export declare const lookAlikes: (components: readonly ScannedComponent[]) => LookAlike[];

package/dist/src/vite/lookAlikes.js

@@ -0,0 +1,228 @@
+/** Words around a name that say which of a kind it is, and not what kind. */
+const VARIANT_WORD = /^(?:Primary|Secondary|Tertiary|Base|Custom|Styled|My|App|New|Old|Legacy|Simple|Default|Main|Ui|UI|Shared|Common|Core|Basic|Generic|Global|Small|Large|Big|V\d+)$/;
+/** Names of one thing, in the words code uses. */
+const SAME_THING = {
+    Btn: "Button",
+    Modal: "Dialog",
+    Popup: "Dialog",
+    Spinner: "Loader",
+    Pill: "Badge",
+    Chip: "Badge",
+    Textbox: "Input",
+    TextField: "Input",
+    TextInput: "Input",
+    Dropdown: "Select",
+    Snackbar: "Toast"
+};
+/** Names so general, or given by a framework's convention, that two of them have nothing to do with each other. */
+const GENERAL_NAME = /^(?:App|Page|Layout|Root|Loading|Error|NotFound|Template|Default|Index|Home|Main|Provider|Providers|Wrapper|Container|Content|Header|Footer|Item|Row|Icon|Form|Title|Label|Link|Section|Component|Body|View|Screen|List|Logo)$/;
+/** A file that is a route or an entry, whose component is the screen and not something to share. */
+const ROUTE_FILE = /(?:^|\/)(?:page|layout|route|loading|error|not-found|template|default|_app|_document|\+page|\+layout|\+error)\.[^/]+$|(?:^|\/)(?:routes|pages|screens|views)\//;
+/** A name that says it is a screen or a framework's hook into one. */
+const SCREEN_NAME = /(?:Page|Layout|Screen|View|Boundary|Fallback|Route)$/;
+/** What every component may render at its root, which says nothing of what it is; a project's component is reuse. */
+const TELLING_ROOT = /^(?:button|a|input|select|textarea|label|dialog|table|nav|form|img|ul|ol|progress|meter)$/;
+/** The roots whose look alone tells two components are one: what a person presses or fills in. */
+const CONTROL_ROOT = /^(?:button|a|input|select|textarea|label)$/;
+/** Props every component takes, which say nothing of what it is. */
+const UNTELLING_PROPS = new Set([
+    "children",
+    "className",
+    "class",
+    "style",
+    "id",
+    "ref",
+    "key",
+    "props",
+    "slot"
+]);
+/**
+ * The sign of a copy, the surest there is, so it counts twice.
+ */
+export const SAME_CODE = "the same code";
+/** The sign of two components with one look. */
+const SAME_CLASSES = "nearly the same classes";
+/** How much two lists of classes share, to read as one look. */
+const SAME_LOOK = 0.7;
+/** Fewer classes than this say nothing of a look. */
+const FEWEST_CLASSES = 4;
+/** How many controls are compared by look, each with each: more are left out rather than let a report take minutes. */
+const MOST_COMPARED = 2000;
+/** How many components of one name are compared: past this they are a convention, not copies. */
+const MOST_OF_A_NAME = 60;
+/** Fewer shared props than this are a coincidence. */
+const FEWEST_PROPS = 2;
+/**
+ * What a component's name says it is, without the words for which of a kind it is.
+ *
+ * @param name - its name.
+ */
+export const stemOf = (name) => {
+    const words = name.match(/[A-Z]+(?![a-z])|[A-Z][a-z0-9]*|[a-z0-9]+/g) ?? [name];
+    const told = words.filter((word, index) => !(VARIANT_WORD.test(word) && words.length > 1 && index < words.length));
+    const kept = told.length === 0 ? words : told;
+    const whole = kept.join("");
+    const last = kept.at(-1) ?? "";
+    return SAME_THING[whole] ?? [...kept.slice(0, -1), SAME_THING[last] ?? last].join("");
+};
+/** How much two lists have in common, from 0 to 1. */
+const overlap = (first, second) => {
+    const [a, b] = [new Set(first), new Set(second)];
+    const shared = [...a].filter((each) => b.has(each)).length;
+    return a.size + b.size === 0 ? 0 : shared / (a.size + b.size - shared);
+};
+/**
+ * What two components have in common, each a sign they are one.
+ *
+ * @param first - one.
+ * @param second - the other.
+ */
+export const signsBetween = (first, second) => {
+    const shared = first.props.filter((prop) => !UNTELLING_PROPS.has(prop) && second.props.includes(prop));
+    const hasSameLook = first.classes.length >= FEWEST_CLASSES &&
+        second.classes.length >= FEWEST_CLASSES &&
+        overlap(first.classes, second.classes) >= SAME_LOOK;
+    return [
+        ...(first.code !== undefined && first.code === second.code ? [SAME_CODE, SAME_CODE] : []),
+        ...(first.root !== undefined && first.root === second.root && TELLING_ROOT.test(first.root)
+            ? [`both render ${first.root}`]
+            : []),
+        ...(shared.length >= FEWEST_PROPS ? [`both take ${shared.slice(0, 4).join(", ")}`] : []),
+        ...(hasSameLook ? [SAME_CLASSES] : [])
+    ];
+};
+/** What a name's last word says it would render, for what a person presses or fills in. */
+const NATIVE_OF = {
+    Button: "button",
+    Input: "input",
+    Select: "select",
+    Textarea: "textarea",
+    Link: "a",
+    Dialog: "dialog"
+};
+/**
+ * Whether a component of a name renders by hand the element a component of that name exists for: an agent's way of
+ * rebuilding one, whatever the other's root (often a slot this cannot read) and props.
+ *
+ * @param added - the new one.
+ * @param stem - what both names say they are.
+ */
+export const isRebuilt = (added, stem) => {
+    const last = stem.match(/[A-Z][a-z0-9]*/g)?.at(-1) ?? stem;
+    const native = NATIVE_OF[stem];
+    return stem === last && native !== undefined && added.root === native;
+};
+/**
+ * Whether one is built on the other: reuse, not a copy.
+ *
+ * @param first - one.
+ * @param second - the other.
+ */
+export const isBuiltOn = (first, second) => first.renders.includes(second.name) || second.renders.includes(first.name);
+/**
+ * Whether a component is one to share: a screen is one of a kind, however alike its layout.
+ *
+ * @param component - the component.
+ */
+export const isShareable = ({ file, name }) => !ROUTE_FILE.test(file) && !SCREEN_NAME.test(name);
+/** Joins pairs that share a component into groups. */
+const joined = (pairs) => {
+    const parents = new Map();
+    const rootOfGroup = (each) => {
+        let root = each;
+        for (let parent = parents.get(root); parent !== undefined; parent = parents.get(root))
+            root = parent;
+        if (root !== each)
+            parents.set(each, root);
+        return root;
+    };
+    const members = new Set(pairs.flat());
+    for (const [first, second] of pairs) {
+        const [one, two] = [rootOfGroup(first), rootOfGroup(second)];
+        if (one !== two)
+            parents.set(one, two);
+    }
+    const groups = new Map();
+    for (const each of members) {
+        const root = rootOfGroup(each);
+        groups.set(root, [...(groups.get(root) ?? []), each]);
+    }
+    return [...groups.values()];
+};
+/** The groups of one name whose members have signs of being one, any member against any other. */
+const groupsOfName = (stem, members) => {
+    const pairs = members.slice(0, MOST_OF_A_NAME).flatMap((first, index) => members.slice(index + 1, MOST_OF_A_NAME).flatMap((second) => {
+        if (first.file === second.file || isBuiltOn(first, second))
+            return [];
+        const signs = signsBetween(first, second);
+        // a general name with one thing in common is two things that happen to share a word
+        return signs.length >= (GENERAL_NAME.test(stem) ? 2 : 1) ? [[first, second]] : [];
+    }));
+    return joined(pairs).map((group) => {
+        const signs = [
+            ...new Set(group.flatMap((one, index) => group.slice(index + 1).flatMap((two) => signsBetween(one, two))))
+        ];
+        return {
+            confidence: signs.length >= 2 || signs.includes(SAME_CODE) ? "high" : "medium",
+            why: `named alike (${stem}): ${signs.join(", ")}`,
+            members: group.map(({ name, file, line }) => ({ name, file, line }))
+        };
+    });
+};
+/** Controls that look alike whatever they are called: the same element, with nearly the same classes and the same props. */
+const groupsByLook = (components) => {
+    const pairs = components.flatMap((first, index) => components.slice(index + 1).flatMap((second) => {
+        if (first.file === second.file || isBuiltOn(first, second))
+            return [];
+        const isSameLook = first.root === second.root && signsBetween(first, second).includes(SAME_CLASSES);
+        return isSameLook ? [[first, second]] : [];
+    }));
+    return joined(pairs).map((members) => ({
+        confidence: "medium",
+        why: `all render ${members[0]?.root ?? "the same"}, with nearly the same classes`,
+        members: members.map(({ name, file, line }) => ({ name, file, line }))
+    }));
+};
+/** Copies under other names: nothing but the code tells them, and that is enough. */
+const groupsByCode = (components, inGroup) => {
+    const byCode = new Map();
+    for (const each of components) {
+        if (each.code !== undefined && !inGroup.has(`${each.file}\0${each.name}`)) {
+            byCode.set(each.code, [...(byCode.get(each.code) ?? []), each]);
+        }
+    }
+    return [...byCode.values()].flatMap((members) => {
+        const files = new Set(members.map(({ file }) => file));
+        return files.size < 2
+            ? []
+            : [
+                {
+                    confidence: "high",
+                    why: SAME_CODE,
+                    members: members.map(({ name, file, line }) => ({ name, file, line }))
+                }
+            ];
+    });
+};
+/**
+ * The components that look like one: first by name, then by look across names. Screens are left out: each is one of a
+ * kind, however alike their layouts.
+ *
+ * @param components - every component of the project.
+ */
+export const lookAlikes = (components) => {
+    const shareable = components.filter(isShareable);
+    const byStem = new Map();
+    for (const each of shareable) {
+        const stem = stemOf(each.name);
+        byStem.set(stem, [...(byStem.get(stem) ?? []), each]);
+    }
+    const named = [...byStem].flatMap(([stem, members]) => groupsOfName(stem, members));
+    const inGroup = new Set(named.flatMap(({ members }) => members.map(({ file, name }) => `${file}\0${name}`)));
+    const looked = shareable
+        .filter((each) => CONTROL_ROOT.test(each.root ?? "") &&
+        each.classes.length >= FEWEST_CLASSES &&
+        !inGroup.has(`${each.file}\0${each.name}`))
+        .slice(0, MOST_COMPARED);
+    return [...named, ...groupsByLook(looked), ...groupsByCode(shareable, inGroup)].toSorted((first, second) => Number(first.confidence === "medium") - Number(second.confidence === "medium"));
+};

package/dist/src/vite/nearestToken.d.ts

@@ -40,6 +40,23 @@ export type NearestTokens = {
     /** Why the question could not be answered: the value or the type could not be read. */
     readonly reason?: string;
 };
+/** A colour in Oklab, with its alpha. */
+export type OklabColor = {
+    /** Its lightness, from 0 to 1. */
+    readonly l: number;
+    /** How far from green to red. */
+    readonly a: number;
+    /** How far from blue to yellow. */
+    readonly b: number;
+    /** Its opacity, from 0 to 1. */
+    readonly alpha: number;
+};
+/**
+ * A colour as CSS writes it, in Oklab; none for what cannot be read. Keywords beyond these three carry no design.
+ *
+ * @param written - the colour, as code writes it.
+ */
+export declare const parsedColor: (written: string) => OklabColor | undefined;
 /**
  * The tokens nearest a value, nearest first. Deprecated tokens are left out: code must not move onto one.
  *

package/dist/src/vite/nearestToken.js

@@ -131,6 +131,9 @@ const functionColor = (text) => {
     if (call === undefined)
         return undefined;
     const { name, parts, alpha } = call;
+    // more channels than a colour has is text that happens to start like one
+    if (parts.length > (name === "color" ? 4 : 3))
+        return undefined;
     const [first = "", second = "", third = "", fourth = ""] = parts;
     const fromRgb = () => fromSrgb(percentOf(first, 255) / 255, percentOf(second, 255) / 255, percentOf(third, 255) / 255, alpha);
     const fromHsl = () => {
@@ -155,8 +158,12 @@ const functionColor = (text) => {
     };
     return convert[name]?.();
 };
-/** A colour as CSS writes it, in Oklab; none for what cannot be read. Keywords beyond these three carry no design. */
-const parsedColor = (written) => {
+/**
+ * A colour as CSS writes it, in Oklab; none for what cannot be read. Keywords beyond these three carry no design.
+ *
+ * @param written - the colour, as code writes it.
+ */
+export const parsedColor = (written) => {
     const text = written.trim().toLowerCase();
     if (text === "transparent")
         return fromSrgb(0, 0, 0, 0);

package/dist/src/vite/packageEntries.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Which source files a package publishes: its manifest's entries, led back from the build they name to the file they
+ * are built from.
+ *
+ * @remarks
+ * Pure. A manifest names what is built (`./dist/index.js`), which a fresh clone does not hold and an agent never reads, so
+ * each entry is looked for under `src` by what is left of its path once the build's folders are taken off, the longest
+ * rest first (`dist/esm/button/index.js` is `src/dist/esm/button/index`, then `src/esm/button/index`, then `src/button/index`, each
+ * under `src/js` too, where a JavaScript library may keep its sources). What cannot be led back is
+ * named, and never read as a package with nothing in it. A private package counts only when it has an entry to
+ * import: a workspace's shared library is published to its neighbours, while an application or a monorepo's root is not.
+ *
+ * @module
+ */
+/** What a package publishes. */
+export type PackageEntries = {
+    /** The entries' source files, absolute. */
+    readonly entries: readonly string[];
+    /** The entries that could not be led back to a source, as the manifest writes them. */
+    readonly unread: readonly string[];
+};
+/** What `packageEntries` asks of the disk. */
+export type EntryDisk = {
+    /** Whether a file exists, by its absolute path. */
+    readonly exists: (file: string) => boolean;
+    /** Every file under a folder, absolute; none when it does not exist. */
+    readonly filesUnder: (folder: string) => readonly string[];
+};
+/**
+ * Whether a package publishes anything: public, or private with an entry its neighbours import.
+ *
+ * @param manifest - the package's manifest.
+ */
+export declare const isPublished: (manifest: unknown) => boolean;
+/**
+ * What a package publishes, as source files.
+ *
+ * @param manifest - the package's manifest.
+ * @param dir - its folder, absolute, with no trailing slash.
+ * @param disk - what is asked of the disk.
+ */
+export declare const packageEntries: (manifest: unknown, dir: string, disk: EntryDisk) => PackageEntries;

package/dist/src/vite/packageEntries.js

@@ -0,0 +1,127 @@
+/**
+ * Which source files a package publishes: its manifest's entries, led back from the build they name to the file they
+ * are built from.
+ *
+ * @remarks
+ * Pure. A manifest names what is built (`./dist/index.js`), which a fresh clone does not hold and an agent never reads, so
+ * each entry is looked for under `src` by what is left of its path once the build's folders are taken off, the longest
+ * rest first (`dist/esm/button/index.js` is `src/dist/esm/button/index`, then `src/esm/button/index`, then `src/button/index`, each
+ * under `src/js` too, where a JavaScript library may keep its sources). What cannot be led back is
+ * named, and never read as a package with nothing in it. A private package counts only when it has an entry to
+ * import: a workspace's shared library is published to its neighbours, while an application or a monorepo's root is not.
+ *
+ * @module
+ */
+/** The extensions an entry's source may have, the likeliest first. */
+const SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".jsx", ".js", ".mjs", ".vue", ".svelte"];
+/** A file a manifest may name that has no components to follow. */
+const NOT_CODE = /\.(?:css|scss|sass|less|json|svg|png|d\.[cm]?ts|map)$/;
+/** A file a pattern's folder holds that no one imports from the package: its stories and tests. */
+const NOT_PUBLISHED = /\.(?:stories|test|spec)\.[^/]+$|(?:^|\/)__(?:tests|stories|mocks)__\//;
+/** A file that is written by hand wherever it sits: a JavaScript file may be a build's. */
+const WRITTEN_SOURCE = /\.(?:[cm]?tsx?|jsx|vue|svelte)$/;
+/** Whether a value is a plain object. */
+const isManifest = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Every path an `exports` value leads to, whatever its conditions. */
+const exportTargets = (value) => {
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(exportTargets);
+    return isManifest(value) ? Object.values(value).flatMap(exportTargets) : [];
+};
+/**
+ * The paths a manifest names, with no duplicates. A path climbing out of the package is left to be named as unread: Node
+ * refuses one, and following it would read what the repository does not hold.
+ */
+const namedPaths = (manifest) => {
+    const fields = [manifest["source"], manifest["svelte"], manifest["module"], manifest["main"]].filter((each) => typeof each === "string");
+    return [...new Set([...exportTargets(manifest["exports"]), ...fields])].filter((each) => !NOT_CODE.test(each));
+};
+/** Whether a path a manifest names climbs out of its package. */
+const climbsOut = (path) => path.split("/").includes("..");
+/**
+ * Whether a package publishes anything: public, or private with an entry its neighbours import.
+ *
+ * @param manifest - the package's manifest.
+ */
+export const isPublished = (manifest) => {
+    if (!isManifest(manifest) || typeof manifest["name"] !== "string")
+        return false;
+    if (manifest["private"] !== true)
+        return true;
+    return manifest["exports"] !== undefined || manifest["source"] !== undefined;
+};
+/** A path's folders and its name without its extension. */
+const withoutExtension = (path) => path.replace(/^\.\//, "").replace(/\.[cm]?[jt]sx?$/, "");
+/** The first source file a path with no extension is, as a file or a folder's index. */
+const sourceAt = (bare, exists) => {
+    for (const form of [bare, `${bare}/index`]) {
+        for (const extension of SOURCE_EXTENSIONS) {
+            if (exists(`${form}${extension}`))
+                return `${form}${extension}`;
+        }
+    }
+    return undefined;
+};
+/** The source of a built path: under `src`, by the longest rest of the path that is there. */
+const builtFrom = (path, dir, exists) => {
+    const parts = withoutExtension(path).split("/");
+    for (let start = 0; start < parts.length; start += 1) {
+        const rest = parts.slice(start).join("/");
+        const found = sourceAt(`${dir}/src/${rest}`, exists) ?? sourceAt(`${dir}/src/js/${rest}`, exists);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+};
+/** The sources a `./dist/*.js` pattern stands for: every source under the folder the pattern's start leads to. */
+const patternSources = (path, dir, disk) => {
+    const [start = ""] = path.split("*");
+    const parts = start.replace(/^\.\//, "").split("/").slice(0, -1);
+    for (let from = 0; from <= parts.length; from += 1) {
+        const rest = parts.slice(from).join("/");
+        const folder = from === 0 ? `${dir}/${rest}` : `${dir}/src${rest === "" ? "" : `/${rest}`}`;
+        const inSource = disk.filesUnder(folder);
+        const sources = inSource.filter((file) => WRITTEN_SOURCE.test(file) && !NOT_CODE.test(file) && !NOT_PUBLISHED.test(file));
+        if (sources.length > 0)
+            return sources;
+    }
+    return [];
+};
+/** The sources one path a manifest names stands for: none when it cannot be led back. */
+const sourcesOf = (path, dir, disk) => {
+    if (climbsOut(path))
+        return [];
+    if (path.includes("*"))
+        return patternSources(path, dir, disk);
+    const named = `${dir}/${path.replace(/^\.\//, "")}`;
+    if (disk.exists(named) && WRITTEN_SOURCE.test(named))
+        return [named];
+    const built = builtFrom(path, dir, disk.exists);
+    if (built !== undefined)
+        return [built];
+    return disk.exists(named) ? [named] : [];
+};
+/**
+ * What a package publishes, as source files.
+ *
+ * @param manifest - the package's manifest.
+ * @param dir - its folder, absolute, with no trailing slash.
+ * @param disk - what is asked of the disk.
+ */
+export const packageEntries = (manifest, dir, disk) => {
+    if (!isManifest(manifest))
+        return { entries: [], unread: [] };
+    const paths = namedPaths(manifest);
+    // a manifest with no entries at all means an index, as Node reads it
+    if (paths.length === 0) {
+        const index = sourceAt(`${dir}/src/index`, disk.exists) ?? sourceAt(`${dir}/index`, disk.exists);
+        return { entries: index === undefined ? [] : [index], unread: [] };
+    }
+    const found = paths.map((path) => ({ path, sources: sourcesOf(path, dir, disk) }));
+    return {
+        entries: [...new Set(found.flatMap(({ sources }) => sources))],
+        unread: found.filter(({ sources }) => sources.length === 0).map(({ path }) => path)
+    };
+};

package/dist/src/vite/pages.d.ts

@@ -9,6 +9,8 @@ export type PageFile = (typeof PAGE_FILES)[number];
 export declare const CONFIG_MODULE = "virtual:forgebook/config";
 /** The module the shell reads the design tokens from, imported on first use: a page that shows none never loads it. */
 export declare const TOKENS_MODULE = "virtual:forgebook/tokens";
+/** The previews of the catalogue's galleries, with each picture's address: loaded when a gallery first opens. */
+export declare const SWITCH_PREVIEWS_MODULE = "virtual:forgebook/switch-previews";
 /**
  * The entries the pages load, by page: file names in the configuration's folder, never written to disk. Named as
  * files rather than virtual modules because the build names a page's chunk and its style sheet after its entry, and a
@@ -59,13 +61,19 @@ export declare const pageModuleOf: (path: string, dir: string, paths?: VitePaths
  * @param placement - where the frames run, which the frame's load guard tells its errors by.
  */
 export declare const pageHtml: (page: PageFile, config: ResolvedConfig, placement: FramesPlacement) => string;
+/**
+ * The module of the galleries' previews: by switch id then value, with each picture's address.
+ *
+ * @param config - the configuration.
+ */
+export declare const switchPreviewsModule: (config: Pick<ResolvedConfig, "switches">) => string;
 /**
  * The configuration's data, as the pages' module exports it.
  *
  * @param config - the configuration.
  * @param frames - where the frames run: known on the dev server once both of its ports listen.
  */
-export declare const configModule: (config: ResolvedConfig, frames: FramesPlacement) => string;
+export declare const configModule: (config: Pick<ResolvedConfig, "title" | "heights" | "switches" | "stories" | "languages" | "lists">, frames: FramesPlacement, isServing: boolean) => string;
 /** The module the entry loads the written home's view from, on first use. */
 export declare const WRITTEN_HOME_MODULE = "forgebook/shell/home";
 /** The module the entry loads the code that draws the plugins' views from, on first use. */