@forgebook/solid 0.0.0-stage → 0.2.1

package/LICENSE

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

@@ -1,3 +1,69 @@
-# Temporary Holding Version
+# @forgebook/solid
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Solid for [Forgebook](https://www.npmjs.com/package/forgebook): the story types, the primitives, the renderer the frame
+mounts a story with, and the adapter that reads a component's props from its TypeScript types.
+
+**Requirements:** Solid 1.9 · `forgebook` · Vite 8 · React in the project, for the catalogue's own interface (the frames
+that draw your components load none) · [MIT licence](https://github.com/ensiria/forgebook/blob/develop/packages/solid/LICENSE)
+
+```sh
+npm install --save-dev forgebook @forgebook/solid react react-dom
+```
+
+The catalogue's configuration names it as its framework:
+
+```ts
+// forgebook.config.ts
+import { solid } from "@forgebook/solid/vite";
+import { defineConfig } from "forgebook";
+
+export default defineConfig({ framework: solid(), title: "My components", stories: ["src/**/*.stories.tsx"] });
+```
+
+and the stories take their types from it:
+
+```tsx
+import type { Meta, Story } from "@forgebook/solid";
+
+import { Badge } from "./Badge";
+
+export default { title: "Components/Badge", component: Badge } satisfies Meta<typeof Badge>;
+
+export const Default: Story<typeof Badge> = { args: { label: "New" } };
+
+// a render runs once: read the args inside its JSX, or spread them, and each new value reaches the story in place
+export const Inline: Story<typeof Badge> = {
+  render: (args) => (
+    <p>
+      Status: <Badge label="" {...args} />
+    </p>
+  )
+};
+```
+
+| Import | What it is |
+|---|---|
+| `@forgebook/solid` | `Meta`, `Story`, `Decorator`, `Preview`, `LogicMeta`: CSF 3 typed for Solid, the args from the component's props |
+| `@forgebook/solid/vite` | `solid()`, the framework adapter of `forgebook.config.ts`, with Solid's Vite plugin |
+| `@forgebook/solid/texts`, `@forgebook/solid/clock` | A story's texts in the catalogue's language (`useStoryText`), and the story clock as accessors (`useStoryNow()`) |
+
+## What the catalogue does with Solid
+
+A story runs once, as a Solid component does. New args from the panel, Replay or the events do not draw it again: each arg
+is a signal of its own, and only what reads it updates, so a counter keeps its count and an open menu stays open. An arg
+holds the value the story passed (an option object is that object, not a store's copy). The language, the switches a
+decorator reads in `context.globals` and the story clock follow the same way. Read the args where Solid can follow them:
+inside JSX or spread, never destructured at the top of a render. A story that reads a resource is ready, for its play
+function, once the resource has loaded; what a story or its effects throw is shown in place of the story, and the next
+args try it again.
+
+Solid's plugin is the adapter's, so don't add `vite-plugin-solid` to a catalogue: it compiles your stories and
+components, refreshes an edited one in its frame, and leaves the catalogue's own React alone.
+
+Generated server tests run on Node, with Solid's server build: in the Vitest configuration they run in, give the plugin
+`solid({ ssr: true })` and `environment: "node"`, then take `solidRenderer` from `@forgebook/solid/renderer`. They wait
+for a story's resources. `forgebook new`, `forgebook docs --framework solid` and `forgebook init --from storybook` (from
+`storybook-solidjs-vite`) read Solid too.
+
+The rest of its exports are what the catalogue loads itself. Getting started, the catalogue's features and its commands:
+[Forgebook's README](https://github.com/ensiria/forgebook/blob/develop/packages/forgebook/README.md).

package/dist/src/clock.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The story clock for Solid components inside a story: the clock the catalogue runs, held at the Unix epoch outside a
+ * catalogue.
+ *
+ * @remarks
+ * The clock itself is the format's (`@forgebook/story-format/clock`); this module is how a Solid component reads it,
+ * as accessors, Solid's way: the moment read inside JSX follows the clock's ticks and nothing else runs again. The
+ * frame's renderer provides it (`solidRenderer.ts`).
+ *
+ * @module
+ */
+import { type StoryClock } from "@forgebook/story-format/clock";
+import { type Accessor } from "solid-js";
+/** The story clock of the frame: held at the Unix epoch outside a catalogue. */
+export declare const StoryClockContext: import("solid-js").Context<Accessor<StoryClock>>;
+/**
+ * The story's clock, for a component inside a story.
+ *
+ * @returns the clock the catalogue runs for the story, as an accessor.
+ */
+export declare const useStoryClock: () => Accessor<StoryClock>;
+/**
+ * The story's current moment, following each tick of the clock.
+ *
+ * @returns the moment, in milliseconds since the Unix epoch, as an accessor.
+ */
+export declare const useStoryNow: () => Accessor<number>;

package/dist/src/clock.js

@@ -0,0 +1,36 @@
+/**
+ * The story clock for Solid components inside a story: the clock the catalogue runs, held at the Unix epoch outside a
+ * catalogue.
+ *
+ * @remarks
+ * The clock itself is the format's (`@forgebook/story-format/clock`); this module is how a Solid component reads it,
+ * as accessors, Solid's way: the moment read inside JSX follows the clock's ticks and nothing else runs again. The
+ * frame's renderer provides it (`solidRenderer.ts`).
+ *
+ * @module
+ */
+import { heldStoryClock } from "@forgebook/story-format/clock";
+import { createContext, createRenderEffect, createSignal, onCleanup, useContext } from "solid-js";
+/** The story clock of the frame: held at the Unix epoch outside a catalogue. */
+export const StoryClockContext = createContext(() => heldStoryClock(0));
+/**
+ * The story's clock, for a component inside a story.
+ *
+ * @returns the clock the catalogue runs for the story, as an accessor.
+ */
+export const useStoryClock = () => useContext(StoryClockContext);
+/**
+ * The story's current moment, following each tick of the clock.
+ *
+ * @returns the moment, in milliseconds since the Unix epoch, as an accessor.
+ */
+export const useStoryNow = () => {
+    const clock = useStoryClock();
+    const [now, setNow] = createSignal(clock().now());
+    createRenderEffect(() => {
+        const current = clock();
+        setNow(current.now());
+        onCleanup(current.subscribe(() => setNow(current.now())));
+    });
+    return now;
+};

package/dist/src/code.d.ts

@@ -0,0 +1,3 @@
+import type { StoryCodeWriter } from "forgebook/renderer";
+/** The code writer a Solid catalogue's shell writes a story's code with. */
+export declare const codeOf: StoryCodeWriter;

package/dist/src/code.js

@@ -0,0 +1,9 @@
+/**
+ * The code writer a Solid catalogue's shell writes a story's code with: the JSX every framework written in JSX shares
+ * (`forgebook/jsx-code`), under the name the generated pages import.
+ *
+ * @module
+ */
+import { jsxCode } from "forgebook/jsx-code";
+/** The code writer a Solid catalogue's shell writes a story's code with. */
+export const codeOf = jsxCode;

package/dist/src/liveRecord.d.ts

@@ -0,0 +1,17 @@
+/** A record followed value by value, and how to set it. */
+export type LiveRecord<TValue> = {
+    /** The record: reading a value inside a reactive scope follows it. */
+    readonly record: Readonly<Record<string, TValue>>;
+    /**
+     * Makes the record equal to new values: a value that did not change notifies no one.
+     *
+     * @param next - the new values.
+     */
+    readonly assign: (next: Readonly<Record<string, TValue>>) => void;
+};
+/**
+ * A record followed value by value.
+ *
+ * @param initial - its first values.
+ */
+export declare const liveRecord: <TValue>(initial: Readonly<Record<string, TValue>>) => LiveRecord<TValue>;

package/dist/src/liveRecord.js

@@ -0,0 +1,66 @@
+/**
+ * A record whose every value is a signal of its own: what the Solid renderer hands a story as its args and its
+ * `globals`, so new values reach the places that read them and nothing else runs again.
+ *
+ * @remarks
+ * Solid's store would do the same, but it wraps every plain object and array inside as a store too: an option a story
+ * passes (`value: OPTIONS[0]`) would no longer be the object the component compares it with. Here the values are kept
+ * as they are, only one level deep. The record carries Solid's `$PROXY` mark, so `mergeProps` and `splitProps` (what
+ * `<Button {...args} />` compiles to) read it lazily as they read a store, and a value set later, or a key added or
+ * removed, still reaches a spread.
+ *
+ * @module
+ */
+import { $PROXY, batch, createSignal } from "solid-js";
+/** Two lists of keys hold the same names in the same order. */
+const isSameKeys = (current, next) => current.length === next.length && current.every((key, index) => key === next[index]);
+/**
+ * A record followed value by value.
+ *
+ * @param initial - its first values.
+ */
+export const liveRecord = (initial) => {
+    const values = new Map();
+    const [keys, setKeys] = createSignal(Object.keys(initial), { equals: isSameKeys });
+    /** The signal of a key, made the first time it is read or set. */
+    const signalOf = (key) => {
+        const existing = values.get(key);
+        if (existing !== undefined)
+            return existing;
+        const made = createSignal(initial[key]);
+        values.set(key, made);
+        return made;
+    };
+    const record = new Proxy({}, {
+        get: (_target, key) => {
+            if (key === $PROXY)
+                return record;
+            if (typeof key !== "string")
+                return undefined;
+            // what every object inherits (`toString`, `hasOwnProperty`) stays the object's, unless an arg takes the name
+            if (!keys().includes(key) && key in Object.prototype)
+                return Reflect.get(Object.prototype, key);
+            return signalOf(key)[0]();
+        },
+        has: (_target, key) => key === $PROXY || (typeof key === "string" && keys().includes(key)),
+        ownKeys: () => [...keys()],
+        getOwnPropertyDescriptor: (_target, key) => typeof key === "string" && keys().includes(key)
+            ? { configurable: true, enumerable: true, value: signalOf(key)[0]() }
+            : undefined,
+        set: () => false,
+        deleteProperty: () => false
+    });
+    const assign = (next) => {
+        // one update for every value: what reads two args runs once
+        batch(() => {
+            for (const key of keys())
+                if (!(key in next))
+                    signalOf(key)[1](undefined);
+            // a function is a value here (an event's handler), not an update of the old one
+            for (const [key, value] of Object.entries(next))
+                signalOf(key)[1](() => value);
+            setKeys(Object.keys(next));
+        });
+    };
+    return { record, assign };
+};

package/dist/src/mountFrame.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The frame page of a Solid catalogue: Forgebook's frame, drawing its stories with Solid. Called by the page the
+ * plugin generates from the catalogue's configuration, not by an app.
+ *
+ * @module
+ */
+import { type FrameConfig } from "forgebook/frame";
+/**
+ * Shows the story the address names in the given element, drawn with Solid.
+ *
+ * @param container - the element the story renders into.
+ * @param config - the sources and the languages, as the shell's configuration gives them.
+ */
+export declare const mountFrame: (container: HTMLElement, config: Omit<FrameConfig, "renderer">) => Promise<void>;

package/dist/src/mountFrame.js

@@ -0,0 +1,15 @@
+/**
+ * The frame page of a Solid catalogue: Forgebook's frame, drawing its stories with Solid. Called by the page the
+ * plugin generates from the catalogue's configuration, not by an app.
+ *
+ * @module
+ */
+import { mountFrame as mountForgebookFrame } from "forgebook/frame";
+import { solidRenderer } from "./solidRenderer.js";
+/**
+ * Shows the story the address names in the given element, drawn with Solid.
+ *
+ * @param container - the element the story renders into.
+ * @param config - the sources and the languages, as the shell's configuration gives them.
+ */
+export const mountFrame = (container, config) => mountForgebookFrame(container, { ...config, renderer: solidRenderer });

package/dist/src/solidRenderer.d.ts

@@ -0,0 +1,3 @@
+import type { StoryRenderer } from "forgebook/renderer";
+/** Solid as the frame draws with it. */
+export declare const solidRenderer: StoryRenderer;

package/dist/src/solidRenderer.js

@@ -0,0 +1,159 @@
+import { storyTextOf } from "@forgebook/story-format/texts";
+import { storyContextOf, untracedStep } from "forgebook/renderer";
+import { createComponent, createSignal, ErrorBoundary, onMount, Show, Suspense } from "solid-js";
+import { render, renderToStringAsync } from "solid-js/web";
+import { StoryClockContext } from "./clock.js";
+import { liveRecord } from "./liveRecord.js";
+import { storyNode } from "./storyNode.js";
+import { StoryTextsContext } from "./texts.js";
+/** An error as the frame takes it. */
+const toError = (error) => (error instanceof Error ? error : new Error(String(error)));
+/**
+ * Whether two drawings draw the same story: by its id, as the frame names it. A drawing of the same story is the same
+ * story drawn again with other values, however it was read (the frame reads it once; a test may read it anew), so its
+ * args, switches and texts go into what it holds; another story starts over.
+ *
+ * @param current - the drawing on screen.
+ * @param next - the new one.
+ */
+const isSameStory = (current, next) => current.identity.id === next.identity.id;
+/**
+ * The story in the texts' and the clock's providers; the language's provider is a decorator of the catalogue's
+ * preview, inside these.
+ *
+ * @param texts - the shown language's texts.
+ * @param clock - the story's clock.
+ * @param story - draws the story.
+ */
+const inProviders = (texts, clock, story) => createComponent(StoryTextsContext.Provider, {
+    value: texts,
+    get children() {
+        return createComponent(StoryClockContext.Provider, {
+            value: clock,
+            get children() {
+                return story();
+            }
+        });
+    }
+});
+/**
+ * What a render and a decorator receive, reading the moment's values when they are read: what reads them inside JSX
+ * follows them.
+ *
+ * @param args - the live args.
+ * @param view - the live view.
+ * @param canvas - the story's canvas.
+ */
+const liveContext = (args, view, canvas) => ({
+    args,
+    step: untracedStep,
+    canvasElement: canvas,
+    get text() {
+        return (key, values) => storyTextOf(view.texts())(key, values);
+    },
+    get clock() {
+        return view.clock();
+    },
+    globals: view.globals,
+    get loaded() {
+        return view.loaded();
+    },
+    get id() {
+        return view.scene().identity.id;
+    },
+    get name() {
+        return view.scene().identity.name;
+    },
+    get title() {
+        return view.scene().identity.title;
+    },
+    get parameters() {
+        return view.scene().story.parameters;
+    }
+});
+/** Solid as the frame draws with it. */
+export const solidRenderer = {
+    mount: (canvas, first, onError) => {
+        const args = liveRecord(first.args);
+        const globals = liveRecord(first.globals);
+        const [texts, setTexts] = createSignal(first.texts);
+        const [clock, setClock] = createSignal(first.clock);
+        const [loaded, setLoaded] = createSignal(first.loaded);
+        const [scene, setScene] = createSignal(first);
+        /** Whether the story threw, and how to try again. */
+        let failure;
+        let markDrawn = () => undefined;
+        const drawn = new Promise((resolve) => {
+            markDrawn = resolve;
+        });
+        const view = { texts, clock, globals: globals.record, loaded, scene };
+        const context = liveContext(args.record, view, canvas);
+        /** Says the story is drawn, once its effects ran without an error; a component of no output. */
+        const Drawn = () => {
+            onMount(() => {
+                // after the effects of this drain: one of the story's own may still throw in it, and a story that threw is not drawn
+                queueMicrotask(() => {
+                    if (failure === undefined)
+                        markDrawn();
+                });
+            });
+            return null;
+        };
+        /** The story on screen, made again only for another story. */
+        const KeyedStory = () => Show({
+            get when() {
+                return scene();
+            },
+            keyed: true,
+            children: (current) => [
+                storyNode(current.story, context, current.decorators),
+                createComponent(Drawn, {})
+            ]
+        });
+        const dispose = render(() => inProviders(texts, clock, () => createComponent(ErrorBoundary, {
+            fallback: (error, reset) => {
+                if (failure === undefined)
+                    onError(toError(error));
+                failure = { retry: reset };
+                return null;
+            },
+            // read again after an error, so a try starts the story anew
+            get children() {
+                return createComponent(Suspense, {
+                    get children() {
+                        // new args and switches reach the story in place
+                        return createComponent(KeyedStory, {});
+                    }
+                });
+            }
+        })), canvas);
+        return {
+            drawn,
+            update: (next) => {
+                // only an error that stood before these values is tried again: one they cause is reported, and stands
+                const standing = failure;
+                args.assign(next.args);
+                globals.assign(next.globals);
+                setTexts(() => next.texts);
+                setClock(() => next.clock);
+                setLoaded(() => next.loaded);
+                if (!isSameStory(scene(), next))
+                    setScene(() => next);
+                if (standing !== undefined && failure === standing) {
+                    failure = undefined;
+                    standing.retry();
+                }
+            },
+            unmount: dispose
+        };
+    },
+    renderToString: async (drawing) => {
+        const context = storyContextOf(drawing, drawing.args, () => document.body);
+        try {
+            return await renderToStringAsync(() => inProviders(() => drawing.texts, () => drawing.clock, () => storyNode(drawing.story, context, drawing.decorators)));
+        }
+        catch (error) {
+            throw toError(error);
+        }
+    }
+};

package/dist/src/stories.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The story types for Solid: what a story file of a Solid library is written with
+ * (`import type { Meta, Story } from "@forgebook/solid"`).
+ *
+ * @remarks
+ * The format's types (`@forgebook/story-format/csf`) are generic over a framework; these name them for Solid, so a
+ * meta writes `satisfies Meta<typeof Button>` and its stories' args are the component's props, a prop that takes a
+ * text also as `storyText("key")`. A render receives the args as props: reading `args.label` inside JSX follows it,
+ * and spreading them (`<Button {...args} />`) keeps every one live. Types only: a library that writes stories depends
+ * on this package, never on the catalogue that shows them.
+ *
+ * @module
+ */
+import type { Decorator as CsfDecorator, CsfMeta, CsfPreview, CsfStory, StoryParameters, WrittenArg } from "@forgebook/story-format/csf";
+import type { JSX } from "solid-js";
+/**
+ * Any component: a function of its props, run once (Solid's `Component`). The props are what the stories' args fill
+ * in; they are `never` here so a component of any props is assignable.
+ */
+export type AnyComponent = (props: never) => JSX.Element;
+/** Solid, as the format's types read it. */
+export type SolidRenderer = {
+    /** A component. */
+    readonly component: AnyComponent;
+    /** What a story draws. */
+    readonly storyResult: JSX.Element;
+};
+/** A component's props, as its function takes them. */
+type PropsOf<TComponent> = TComponent extends (props: infer TProps) => unknown ? TProps : never;
+/** A component's props, every one optional: what a story's args may set, and what its render receives. */
+export type ArgsOf<TComponent extends AnyComponent> = Partial<PropsOf<TComponent>>;
+/**
+ * What a story's `args` may write: the component's props, every one optional, a prop that takes a text also as
+ * `storyText("key")`. The render and the play function receive `ArgsOf`, the text already in the shown language.
+ */
+export type WrittenArgsOf<TComponent extends AnyComponent> = {
+    [TName in keyof PropsOf<TComponent>]?: WrittenArg<PropsOf<TComponent>[TName]>;
+};
+/** A page with no component (a foundations page): no args. */
+export type NoComponent = () => null;
+/** A Solid story file's default export: `{ title, component, args… } satisfies Meta<typeof Button>`. */
+export type Meta<TComponent extends AnyComponent = NoComponent> = CsfMeta<SolidRenderer, TComponent, ArgsOf<TComponent>, WrittenArgsOf<TComponent>>;
+/** A Solid story: a named export of a story file. */
+export type Story<TComponent extends AnyComponent = NoComponent> = CsfStory<SolidRenderer, ArgsOf<TComponent>, WrittenArgsOf<TComponent>>;
+/** Any primitive or function a story about logic documents (`createUndo`); its parameter is `never` so any signature is assignable. */
+export type AnyFunction = (...parameters: never[]) => unknown;
+/** No args: a story about logic draws a scene of its own, which takes none. */
+type NoArgs = Readonly<Record<string, never>>;
+/**
+ * The default export of a story file about logic, written `satisfies LogicMeta<typeof createUndo>`: `parameters` must say
+ * `logic: true`, so a primitive's file is never taken for a component's. Its component is the primitive or the function, whose
+ * signature the catalogue documents.
+ */
+export type LogicMeta<TFunction extends AnyFunction> = CsfMeta<SolidRenderer, TFunction, NoArgs, NoArgs> & {
+    /** The catalogue's settings, `logic: true` among them. */
+    readonly parameters: StoryParameters & {
+        readonly logic: true;
+    };
+};
+/**
+ * A story about logic: a `render` that draws a scene using the primitive, required (without one, the catalogue would
+ * draw the primitive as a component), and a `play` that tries it.
+ */
+export type LogicStory = CsfStory<SolidRenderer, NoArgs, NoArgs> & Required<Pick<CsfStory<SolidRenderer, NoArgs, NoArgs>, "render">>;
+/** Wraps a Solid story: a provider, a container of a given width. */
+export type Decorator<TArgs> = CsfDecorator<SolidRenderer, TArgs>;
+/**
+ * A Solid catalogue's preview (`forgebook.preview.ts`): decorators around every story (its providers, the language's
+ * reading `context.globals.lang`), parameters under every meta's, a setup before any story renders.
+ */
+export type Preview = CsfPreview<SolidRenderer>;
+export {};

package/dist/src/storyNode.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A story drawn as Solid: its render (or the meta's component) inside its decorators, the story's, the meta's and
+ * the catalogue's (its preview's), in that order outward. The story's canvas and each cell of its matrix draw it the
+ * same way, in a page and on a server.
+ *
+ * @module
+ */
+import type { StoryContext } from "@forgebook/story-format/csf";
+import type { LoadedArgs, LoadedDecorator, LoadedStory } from "forgebook/story-module";
+import { type JSX } from "solid-js";
+/**
+ * The story with these args: its render (or the meta's component, with the args as its props), inside its
+ * decorators. Each part runs once, as a Solid component does; what it reads of the args follows them.
+ *
+ * @param loaded - the story.
+ * @param context - the args and the canvas its render, play and decorators read.
+ * @param outer - the catalogue's decorators, outside the story's and the meta's.
+ */
+export declare const storyNode: (loaded: LoadedStory, context: StoryContext<LoadedArgs>, outer: readonly LoadedDecorator[]) => JSX.Element;

package/dist/src/storyNode.js

@@ -0,0 +1,43 @@
+/**
+ * A story drawn as Solid: its render (or the meta's component) inside its decorators, the story's, the meta's and
+ * the catalogue's (its preview's), in that order outward. The story's canvas and each cell of its matrix draw it the
+ * same way, in a page and on a server.
+ *
+ * @module
+ */
+import { createComponent, untrack } from "solid-js";
+/**
+ * A loaded story read as Solid's: the one place Solid's types meet the story file's module.
+ *
+ * @remarks
+ * The frame reads a story file without its types (`forgebook/story-module`: a function is taken with the signature
+ * CSF gives it), so what its functions return is `unknown` there. A Solid story file is written against
+ * `@forgebook/solid`'s `Meta` and `Story`, and its catalogue's preview against its `Preview`, whose components,
+ * renders and decorators return `JSX.Element`: that is what this view takes on trust, as the frame takes the
+ * functions' parameters.
+ *
+ * @param story - the loaded story.
+ */
+const asSolidStory = (story) => story;
+/**
+ * The story with these args: its render (or the meta's component, with the args as its props), inside its
+ * decorators. Each part runs once, as a Solid component does; what it reads of the args follows them.
+ *
+ * @param loaded - the story.
+ * @param context - the args and the canvas its render, play and decorators read.
+ * @param outer - the catalogue's decorators, outside the story's and the meta's.
+ */
+export const storyNode = (loaded, context, outer) => {
+    const story = asSolidStory({ ...loaded, decorators: [...loaded.decorators, ...outer] });
+    const { component, render } = story;
+    // each part runs untracked, as a component's body does: a decorator writing `{story()}` in its JSX calls it inside
+    // an effect, which would otherwise make the whole story again whenever the render read an arg at its top level
+    const renderStory = () => untrack(() => {
+        if (render !== undefined)
+            return render(context.args, context);
+        // the args themselves are the props, not a copy: a component reads each one as it changes
+        return component === undefined ? null : createComponent(component, context.args);
+    });
+    const decorated = story.decorators.reduce((inner, decorator) => () => untrack(() => decorator(inner, context)), renderStory);
+    return decorated();
+};

package/dist/src/texts.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The texts inside the stories for Solid components inside a story: the shown language's table, as the frame provides
+ * it, read with `useStoryText()`.
+ *
+ * @remarks
+ * The table and the text function are the format's (`@forgebook/story-format/texts`); this module is how a Solid
+ * component reads them. The frame's renderer provides the table as an accessor (`solidRenderer.ts`), so a text read
+ * inside JSX follows the language without the story running again; outside a catalogue there is none, and a text is
+ * its key in brackets.
+ *
+ * @module
+ */
+import { type StoryTextFunction } from "@forgebook/story-format/texts";
+import { type Accessor } from "solid-js";
+/** The texts of the shown language, as the catalogue's frame provides them; none outside a catalogue. */
+export declare const StoryTextsContext: import("solid-js").Context<Accessor<Readonly<Record<string, string>>>>;
+/**
+ * The text function of the shown language, for a component inside a story: each call reads the table of the moment.
+ *
+ * @returns `text(key, values?)`.
+ */
+export declare const useStoryText: () => StoryTextFunction;

package/dist/src/texts.js

@@ -0,0 +1,25 @@
+/**
+ * The texts inside the stories for Solid components inside a story: the shown language's table, as the frame provides
+ * it, read with `useStoryText()`.
+ *
+ * @remarks
+ * The table and the text function are the format's (`@forgebook/story-format/texts`); this module is how a Solid
+ * component reads them. The frame's renderer provides the table as an accessor (`solidRenderer.ts`), so a text read
+ * inside JSX follows the language without the story running again; outside a catalogue there is none, and a text is
+ * its key in brackets.
+ *
+ * @module
+ */
+import { storyTextOf } from "@forgebook/story-format/texts";
+import { createContext, useContext } from "solid-js";
+/** The texts of the shown language, as the catalogue's frame provides them; none outside a catalogue. */
+export const StoryTextsContext = createContext(() => ({}));
+/**
+ * The text function of the shown language, for a component inside a story: each call reads the table of the moment.
+ *
+ * @returns `text(key, values?)`.
+ */
+export const useStoryText = () => {
+    const table = useContext(StoryTextsContext);
+    return (key, values) => storyTextOf(table())(key, values);
+};

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

@@ -0,0 +1,24 @@
+/**
+ * The docs module of `@forgebook/solid`: the plugin's worker and `forgebook-docs` load it through the adapter
+ * (`forgebook/vite/adapter`). A Solid component is a function of its props, run once, read as every such framework's is
+ * (`forgebook/vite/function-component-docs`): its props from the first parameter's type, events as `on*` props, its
+ * parts from its `classNames`, `styles` and `refs` maps.
+ *
+ * @module
+ */
+import type { ComponentDocs, NoComponentDocs } from "forgebook/component-docs";
+import type { ExtractFileComponent, ExtractStoryComponent } from "forgebook/vite/adapter";
+/** The module a Solid story file imports its types from (`Meta`, `Story`), for the stories `forgebook new` writes. */
+export declare const storyTypesModule = "@forgebook/solid";
+/** Reads a story file's component with the file that declares it. */
+export declare const extractStoryComponent: ExtractStoryComponent;
+/** Reads a component a file exports, for writing its first stories (`forgebook new`). */
+export declare const extractFileComponent: ExtractFileComponent;
+/**
+ * The docs of a story file's component.
+ *
+ * @param storyFile - the story file's absolute path.
+ * @returns the component's docs, `{ name: null }` when the meta names no component, or a message saying why the file
+ * cannot be read.
+ */
+export declare const extractComponentDocs: (storyFile: string) => ComponentDocs | NoComponentDocs | string;

package/dist/src/vite/extractDocs.js

@@ -0,0 +1,15 @@
+import { functionComponentDocs, functionFileComponent, functionStoryComponent } from "forgebook/vite/function-component-docs";
+/** The module a Solid story file imports its types from (`Meta`, `Story`), for the stories `forgebook new` writes. */
+export const storyTypesModule = "@forgebook/solid";
+/** Reads a story file's component with the file that declares it. */
+export const extractStoryComponent = functionStoryComponent;
+/** Reads a component a file exports, for writing its first stories (`forgebook new`). */
+export const extractFileComponent = functionFileComponent;
+/**
+ * The docs of a story file's component.
+ *
+ * @param storyFile - the story file's absolute path.
+ * @returns the component's docs, `{ name: null }` when the meta names no component, or a message saying why the file
+ * cannot be read.
+ */
+export const extractComponentDocs = (storyFile) => functionComponentDocs(storyFile);

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

@@ -0,0 +1,21 @@
+import { type FrameworkAdapter } from "forgebook/vite/adapter";
+/** Options of Solid's own Vite plugin, as the adapter passes them on. */
+export type SolidOptions = {
+    /**
+     * Compile the stories for a server render as well (`vite-plugin-solid`'s `ssr`): what the generated server tests
+     * need, run by Vitest on Node, where Solid's JSX must become strings rather than DOM nodes. A catalogue needs none.
+     * `false` by default.
+     */
+    readonly ssr?: boolean;
+};
+/**
+ * Solid, as the plugin reads its components: the docs module the docs' worker loads is this package's `extractDocs.ts`
+ * (the props from the first parameter's type, events as `on*` props); the generated pages draw with its renderer and
+ * write code with the JSX writer; Vite gets Solid's plugin, which compiles the stories' JSX into the DOM operations its
+ * signals update and refreshes an edited component in its frame. The core's own files are left to Vite: its shell is
+ * React.
+ *
+ * @param options - Solid's plugin's options; none for a catalogue.
+ * @returns the adapter.
+ */
+export declare const solid: (options?: SolidOptions) => FrameworkAdapter;

package/dist/src/vite/solid.js

@@ -0,0 +1,28 @@
+/**
+ * Forgebook's adapter for Solid, for the Vite plugin: `forgebookPlugin({ framework: solid() })`.
+ *
+ * @module
+ */
+import { extname } from "node:path";
+import { FORGEBOOK_FILES } from "forgebook/vite/adapter";
+/**
+ * Solid, as the plugin reads its components: the docs module the docs' worker loads is this package's `extractDocs.ts`
+ * (the props from the first parameter's type, events as `on*` props); the generated pages draw with its renderer and
+ * write code with the JSX writer; Vite gets Solid's plugin, which compiles the stories' JSX into the DOM operations its
+ * signals update and refreshes an edited component in its frame. The core's own files are left to Vite: its shell is
+ * React.
+ *
+ * @param options - Solid's plugin's options; none for a catalogue.
+ * @returns the adapter.
+ */
+export const solid = (options = {}) => ({
+    name: "solid",
+    // beside this module, with its extension: `.ts` in the sources, `.js` once built for npm
+    docsModule: new URL(`./extractDocs${extname(import.meta.url)}`, import.meta.url).href,
+    pages: { frame: "@forgebook/solid/frame", code: "@forgebook/solid/code" },
+    browserDependencies: ["solid-js", "solid-js/web"],
+    vitePlugins: async () => {
+        const { default: plugin } = await import("vite-plugin-solid");
+        return [plugin({ exclude: [FORGEBOOK_FILES], ssr: options.ssr ?? false })];
+    }
+});

package/package.json

@@ -1,6 +1,82 @@
 {
   "name": "@forgebook/solid",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.1",
+  "description": "Forgebook for Solid: the story types and primitives, the renderer the frame mounts a story with, args updating in place as signals do, and the adapter that reads a Solid component's props.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ensiria/forgebook.git",
+    "directory": "packages/solid"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.18"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/src/stories.d.ts",
+      "default": "./dist/src/stories.js"
+    },
+    "./clock": {
+      "types": "./dist/src/clock.d.ts",
+      "default": "./dist/src/clock.js"
+    },
+    "./texts": {
+      "types": "./dist/src/texts.d.ts",
+      "default": "./dist/src/texts.js"
+    },
+    "./renderer": {
+      "types": "./dist/src/solidRenderer.d.ts",
+      "default": "./dist/src/solidRenderer.js"
+    },
+    "./frame": {
+      "types": "./dist/src/mountFrame.d.ts",
+      "default": "./dist/src/mountFrame.js"
+    },
+    "./code": {
+      "types": "./dist/src/code.d.ts",
+      "default": "./dist/src/code.js"
+    },
+    "./vite": {
+      "types": "./dist/src/vite/solid.d.ts",
+      "default": "./dist/src/vite/solid.js"
+    },
+    "./docs": {
+      "types": "./dist/src/vite/extractDocs.d.ts",
+      "default": "./dist/src/vite/extractDocs.js"
+    }
+  },
+  "dependencies": {
+    "vite-plugin-solid": "2.11.15",
+    "@forgebook/story-format": "0.2.1"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.9.0",
+    "forgebook": "^0.3.0"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "6.9.1",
+    "@types/node": "24.19.2",
+    "happy-dom": "21.0.4",
+    "solid-js": "1.9.18",
+    "vite": "8.3.5",
+    "vitest": "5.0.5",
+    "@forgebook/tools": "0.0.0",
+    "@forgebook/testing": "0.2.1",
+    "forgebook": "0.3.0",
+    "@forgebook/typescript-config": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "package-build build",
+    "manifest": "package-build manifest",
+    "test": "vitest run",
+    "typecheck": "tsc -p src && tsc -p src/vite && tsc -p test"
+  }
 }