blokd 0.1.0-beta.0 → 0.1.0-beta.2

package/src/hono.ts

@@ -1,368 +0,0 @@
-import { Hono, type Context } from 'hono';
-import {
-  html,
-  isHttpError,
-  json,
-  mergeMeta,
-  renderDocument,
-  renderToString,
-  type MetaDescriptor,
-  type ResponseLike
-} from './server.js';
-import type { Component, Renderable } from './jsx-runtime.js';
-
-export type LoaderArgs<C extends Context = Context> = {
-  request: Request;
-  params: Record<string, string>;
-  ctx: C;
-};
-
-export type ActionArgs<C extends Context = Context> = LoaderArgs<C>;
-
-export type RouteModule<C extends Context = Context> = {
-  default?: Component<any>;
-  loader?: (args: LoaderArgs<C>) => Promise<unknown> | unknown;
-  action?: (args: ActionArgs<C>) => Promise<ResponseLike | Record<string, unknown>> | ResponseLike | Record<string, unknown>;
-  meta?: (args: LoaderArgs<C> & { data: Record<string, unknown>; error?: unknown }) => MetaDescriptor | Promise<MetaDescriptor>;
-  headers?: (args: LoaderArgs<C> & { data: Record<string, unknown>; error?: unknown }) => HeadersInit | Promise<HeadersInit>;
-};
-
-export type RouteEntry<C extends Context = Context> = {
-  id: string;
-  path: string;
-  module: () => Promise<RouteModule<C>>;
-  layouts?: Array<() => Promise<RouteModule<C>>>;
-  error?: () => Promise<RouteModule<C>>;
-  notFound?: () => Promise<RouteModule<C>>;
-  hasClient?: boolean;
-};
-
-export type CreatePagesOptions<C extends Context = Context> = {
-  routes: RouteEntry<C>[];
-  /**
-   * Client entry emitted into documents only when the matched route manifest has hasClient !== false.
-   * Static routes generated by the Vite plugin omit this script automatically.
-   */
-  entryClient?: string;
-  dataQueryParam?: string;
-  onError?: (error: unknown, ctx: C) => Response | Promise<Response>;
-};
-
-type Match<C extends Context = Context> = {
-  entry: RouteEntry<C>;
-  params: Record<string, string>;
-};
-
-type LoadedRoute<C extends Context = Context> = {
-  match: Match<C>;
-  modules: RouteModule<C>[];
-  leaf: RouteModule<C>;
-  data: Record<string, unknown>;
-  meta: MetaDescriptor;
-  headers: Headers;
-};
-
-const actionMethods = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
-
-export function createPages<C extends Context = Context>(options: CreatePagesOptions<C>): Hono {
-  validateRoutes(options.routes);
-  const app = new Hono();
-
-  app.all('*', async c => {
-    const ctx = c as C;
-    const request = c.req.raw;
-    const url = new URL(request.url);
-    const match = matchRoute(options.routes, url.pathname);
-
-    try {
-      if (!match) {
-        const response = await renderNotFound(options.routes, ctx, request);
-        return request.method === 'HEAD' ? withoutBody(response) : response;
-      }
-
-      if (actionMethods.has(request.method)) return await handleAction(match, ctx, options);
-      if (request.method !== 'GET' && request.method !== 'HEAD') {
-        return new Response('Method Not Allowed', { status: 405, headers: { allow: 'GET, HEAD, POST, PUT, PATCH, DELETE' } });
-      }
-
-      const loaded = await loadRoute(match, ctx);
-      if (isDataRequest(request, options.dataQueryParam ?? '__blokd')) {
-        const response = json({ data: loaded.data, meta: loaded.meta }, { headers: loaded.headers });
-        return request.method === 'HEAD' ? withoutBody(response) : response;
-      }
-
-      const response = renderDocumentForLoadedRoute(loaded, ctx, options);
-      return request.method === 'HEAD' ? withoutBody(response) : response;
-    } catch (error) {
-      if (isHttpError(error)) {
-        if (error.response.status < 400) return request.method === 'HEAD' ? withoutBody(error.response) : error.response;
-        if (match && request.method !== 'HEAD' && !isDataRequest(request, options.dataQueryParam ?? '__blokd')) {
-          return renderHttpBoundary(match, ctx, options, error);
-        }
-        return request.method === 'HEAD' ? withoutBody(error.response) : error.response;
-      }
-      if (options.onError) return options.onError(error, ctx);
-      if (match && request.method !== 'HEAD' && !isDataRequest(request, options.dataQueryParam ?? '__blokd')) {
-        return renderErrorBoundary(match, ctx, options, error, 500);
-      }
-      const message = typeof process !== 'undefined' && process.env?.NODE_ENV === 'production'
-        ? 'Internal Server Error'
-        : error instanceof Error ? error.stack ?? error.message : String(error);
-      const response = html(`<pre>${escapeText(message)}</pre>`, { status: 500 });
-      return request.method === 'HEAD' ? withoutBody(response) : response;
-    }
-  });
-
-  return app;
-}
-
-function withoutBody(response: Response): Response {
-  return new Response(null, { status: response.status, statusText: response.statusText, headers: response.headers });
-}
-
-function isDataRequest(request: Request, dataQueryParam: string): boolean {
-  const url = new URL(request.url);
-  if (url.searchParams.has(dataQueryParam)) return true;
-  const accept = request.headers.get('accept') ?? '';
-  return accept.includes('application/json') && !accept.includes('text/html');
-}
-
-async function handleAction<C extends Context>(match: Match<C>, ctx: C, options: CreatePagesOptions<C>): Promise<Response> {
-  try {
-    const leaf = await match.entry.module();
-    if (!leaf.action) return new Response('Method Not Allowed', { status: 405, headers: { allow: 'GET, HEAD' } });
-    const result = await leaf.action({ request: ctx.req.raw, params: match.params, ctx });
-    return normalizeActionResult(result);
-  } catch (error) {
-    if (isHttpError(error)) return error.response;
-    if (options.onError) return options.onError(error, ctx);
-    throw error;
-  }
-}
-
-function normalizeActionResult(result: ResponseLike | Record<string, unknown>): Response {
-  if (result instanceof Response) return result;
-  if (typeof result === 'string') return new Response(result, { headers: { 'content-type': 'text/plain; charset=utf-8' } });
-  if (typeof result === 'number' || typeof result === 'bigint' || typeof result === 'boolean') return json(result);
-  if (result === null || result === undefined) return new Response(null, { status: 204 });
-  if (Array.isArray(result) || isRenderableObject(result)) return html(renderToString(result as Renderable));
-  return json(result);
-}
-
-async function loadRoute<C extends Context>(match: Match<C>, ctx: C): Promise<LoadedRoute<C>> {
-  const layoutModules = await Promise.all((match.entry.layouts ?? []).map(load => load()));
-  const leaf = await match.entry.module();
-  const modules = [...layoutModules, leaf];
-  const data: Record<string, unknown> = {};
-  const headers = new Headers();
-  const metas: MetaDescriptor[] = [];
-
-  for (const mod of modules) {
-    if (mod.loader) {
-      const value = await mod.loader({ request: ctx.req.raw, params: match.params, ctx });
-      if (isPlainRecord(value)) Object.assign(data, value);
-      else data[mod.default?.name || 'value'] = value;
-    }
-  }
-
-  for (const mod of modules) {
-    if (mod.meta) metas.push(await mod.meta({ request: ctx.req.raw, params: match.params, ctx, data }));
-    if (mod.headers) appendHeaders(headers, new Headers(await mod.headers({ request: ctx.req.raw, params: match.params, ctx, data })));
-  }
-
-  return { match, modules, leaf, data, meta: mergeMeta(...metas), headers };
-}
-
-function renderDocumentForLoadedRoute<C extends Context>(loaded: LoadedRoute<C>, ctx: C, options: CreatePagesOptions<C>): Response {
-  const body = renderLoadedRoute(loaded, ctx);
-  const documentOptions: Parameters<typeof renderDocument>[0] = {
-    body,
-    data: { route: loaded.match.entry.id, params: loaded.match.params, data: loaded.data },
-    meta: loaded.meta,
-    headers: loaded.headers
-  };
-  if (options.entryClient !== undefined && loaded.match.entry.hasClient !== false) documentOptions.entryClient = options.entryClient;
-  return renderDocument(documentOptions);
-}
-
-function renderLoadedRoute<C extends Context>(loaded: LoadedRoute<C>, ctx: C): Renderable {
-  if (!loaded.leaf.default) return null;
-  let child: Renderable = loaded.leaf.default({ data: loaded.data, params: loaded.match.params, ctx });
-  for (let i = loaded.modules.length - 2; i >= 0; i--) {
-    const layout = loaded.modules[i];
-    if (layout?.default) child = layout.default({ children: child, data: loaded.data, params: loaded.match.params, ctx });
-  }
-  return child;
-}
-
-async function renderNotFound<C extends Context>(routes: RouteEntry<C>[], ctx: C, request: Request): Promise<Response> {
-  const rootRoute = routes.find(item => normalizePath(item.path) === '/' && (item.notFound || item.error));
-  const route = rootRoute ?? routes.find(item => item.notFound || item.error);
-  if (!route) return new Response('Not Found', { status: 404 });
-  const match: Match<C> = { entry: route, params: {} };
-  return renderBoundary(match, ctx, request, new Error('Not Found'), 404, route.notFound ?? route.error);
-}
-
-function renderHttpBoundary<C extends Context>(match: Match<C>, ctx: C, options: CreatePagesOptions<C>, error: { response: Response }): Promise<Response> | Response {
-  const boundary = error.response.status === 404 ? match.entry.notFound ?? match.entry.error : match.entry.error;
-  if (!boundary) return error.response;
-  return renderBoundary(match, ctx, ctx.req.raw, error, error.response.status, boundary, options.entryClient);
-}
-
-function renderErrorBoundary<C extends Context>(match: Match<C>, ctx: C, options: CreatePagesOptions<C>, error: unknown, status: number): Promise<Response> | Response {
-  if (!match.entry.error) {
-    const message = typeof process !== 'undefined' && process.env?.NODE_ENV === 'production'
-      ? 'Internal Server Error'
-      : error instanceof Error ? error.stack ?? error.message : String(error);
-    return html(`<pre>${escapeText(message)}</pre>`, { status });
-  }
-  return renderBoundary(match, ctx, ctx.req.raw, error, status, match.entry.error, options.entryClient);
-}
-
-async function renderBoundary<C extends Context>(
-  match: Match<C>,
-  ctx: C,
-  request: Request,
-  error: unknown,
-  status: number,
-  loadBoundary?: () => Promise<RouteModule<C>>,
-  entryClient?: string
-): Promise<Response> {
-  if (!loadBoundary) return new Response(status === 404 ? 'Not Found' : 'Internal Server Error', { status });
-  const layoutModules = await Promise.all((match.entry.layouts ?? []).map(load => load()));
-  const boundary = await loadBoundary();
-  const data: Record<string, unknown> = {};
-  const metas: MetaDescriptor[] = [];
-  const headers = new Headers();
-  const modules = [...layoutModules, boundary];
-  for (const mod of modules) {
-    if (mod.meta) metas.push(await mod.meta({ request, params: match.params, ctx, data, error }));
-    if (mod.headers) appendHeaders(headers, new Headers(await mod.headers({ request, params: match.params, ctx, data, error })));
-  }
-  const body = renderBoundaryRoute(modules, { error, status, data, params: match.params, ctx });
-  const documentOptions: Parameters<typeof renderDocument>[0] = {
-    body,
-    data: { route: match.entry.id, params: match.params, data, error: boundaryErrorPayload(error, status) },
-    meta: mergeMeta(...metas),
-    headers,
-    status
-  };
-  if (entryClient !== undefined && match.entry.hasClient !== false) documentOptions.entryClient = entryClient;
-  return renderDocument(documentOptions);
-}
-
-function renderBoundaryRoute<C extends Context>(modules: RouteModule<C>[], props: Record<string, unknown>): Renderable {
-  const leaf = modules.at(-1);
-  let child: Renderable = leaf?.default ? leaf.default(props) : null;
-  for (let i = modules.length - 2; i >= 0; i--) {
-    const layout = modules[i];
-    if (layout?.default) child = layout.default({ ...props, children: child });
-  }
-  return child;
-}
-
-function boundaryErrorPayload(error: unknown, status: number): Record<string, unknown> {
-  if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') return { status };
-  if (isHttpError(error)) return { status: error.response.status, statusText: error.response.statusText };
-  if (error instanceof Error) return { status, name: error.name, message: error.message, stack: error.stack };
-  return { status, message: String(error) };
-}
-
-export function matchRoute<C extends Context>(routes: RouteEntry<C>[], pathname: string): Match<C> | null {
-  const normalized = normalizePath(pathname);
-  const ranked = [...routes].sort(compareRoutes);
-  for (const entry of ranked) {
-    const params = matchPath(entry.path, normalized);
-    if (params) return { entry, params };
-  }
-  return null;
-}
-
-function compareRoutes<C extends Context>(a: RouteEntry<C>, b: RouteEntry<C>): number {
-  const score = scoreRoute(b.path) - scoreRoute(a.path);
-  if (score !== 0) return score;
-  return b.path.length - a.path.length;
-}
-
-function normalizePath(pathname: string): string {
-  if (!pathname.startsWith('/')) pathname = '/' + pathname;
-  pathname = pathname.replace(/\/+/g, '/');
-  if (pathname.length > 1 && pathname.endsWith('/')) pathname = pathname.slice(0, -1);
-  return pathname;
-}
-
-function scoreRoute(path: string): number {
-  return normalizePath(path).split('/').filter(Boolean).reduce((score, segment) => {
-    if (segment.startsWith(':') && segment.endsWith('*')) return score + 1;
-    if (segment.startsWith(':')) return score + 3;
-    return score + 10;
-  }, 0);
-}
-
-function matchPath(pattern: string, pathname: string): Record<string, string> | null {
-  const patternSegments = normalizePath(pattern).split('/').filter(Boolean);
-  const pathSegments = normalizePath(pathname).split('/').filter(Boolean);
-  const params: Record<string, string> = {};
-
-  for (let i = 0, j = 0; i < patternSegments.length; i++, j++) {
-    const patternSegment = patternSegments[i]!;
-    if (patternSegment.startsWith(':') && patternSegment.endsWith('*')) {
-      const key = patternSegment.slice(1, -1);
-      const decoded = safeDecode(pathSegments.slice(j).join('/'));
-      if (decoded === null) return null;
-      params[key] = decoded;
-      return params;
-    }
-    const pathSegment = pathSegments[j];
-    if (pathSegment === undefined) return null;
-    if (patternSegment.startsWith(':')) {
-      const decoded = safeDecode(pathSegment);
-      if (decoded === null) return null;
-      params[patternSegment.slice(1)] = decoded;
-      continue;
-    }
-    if (patternSegment !== pathSegment) return null;
-  }
-
-  return patternSegments.length === pathSegments.length ? params : null;
-}
-
-function safeDecode(value: string): string | null {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return null;
-  }
-}
-
-function validateRoutes<C extends Context>(routes: RouteEntry<C>[]): void {
-  const seen = new Map<string, string>();
-  for (const route of routes) {
-    const normalized = normalizePath(route.path);
-    const previous = seen.get(normalized);
-    if (previous) throw new Error(`Duplicate Blokd route path ${normalized}: ${previous} and ${route.id}`);
-    seen.set(normalized, route.id);
-  }
-}
-
-function appendHeaders(target: Headers, source: Headers): void {
-  source.forEach((value, key) => {
-    if (key.toLowerCase() === 'set-cookie') target.append(key, value);
-    else target.set(key, value);
-  });
-}
-
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  if (isRenderableObject(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-function isRenderableObject(value: unknown): boolean {
-  return !!value && typeof value === 'object' && 'kind' in value;
-}
-
-function escapeText(value: string): string {
-  return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-export { signal, memo, effect, cleanup, batch, untrack, root, getOwner, runWithOwner, dispose } from './core.js';
-export { Show, For, render, hydrate, dynamic } from './dom.js';
-export type { Accessor, Setter } from './core.js';
-export type { Component, Renderable, Props } from './jsx-runtime.js';
-
-export { Island, resumable, startResumability, registerResumable, unregisterResumable, isResumableHandler, parseState, serializeState } from './resume.js';
-export type { JsonValue, ResumeContext, ResumableEventHandler, ResumableHandler } from './resume.js';

package/src/jsx-runtime.ts

@@ -1,306 +0,0 @@
-import { cleanup, effect, getOwner, root } from './core.js';
-import { eventAttributeName, isResumableHandler } from './resume.js';
-
-export type Component<P = Record<string, unknown>> = (props: P) => Renderable;
-export type Lazy<T = unknown> = { readonly __blokdLazy: true; readonly fn: () => T };
-export type Props = Record<string, unknown> & { children?: unknown };
-
-export type VElement = {
-  kind: 'element';
-  tag: string;
-  props: Props;
-  children: Renderable[];
-};
-
-export type VFragment = {
-  kind: 'fragment';
-  children: Renderable[];
-};
-
-export type Dynamic = {
-  kind: 'dynamic';
-  fn: () => unknown;
-};
-
-export type Renderable =
-  | Node
-  | VElement
-  | VFragment
-  | Dynamic
-  | string
-  | number
-  | bigint
-  | boolean
-  | null
-  | undefined
-  | Renderable[];
-
-declare global {
-  namespace JSX {
-    type Element = Renderable;
-    interface ElementChildrenAttribute { children: {}; }
-    interface IntrinsicElements {
-      [elemName: string]: Record<string, unknown>;
-    }
-  }
-}
-
-export const Fragment = Symbol.for('blokd.fragment');
-
-export function lazy<T>(fn: () => T): Lazy<T> {
-  return { __blokdLazy: true, fn };
-}
-
-export function isLazy(value: unknown): value is Lazy {
-  return !!value && typeof value === 'object' && (value as Lazy).__blokdLazy === true;
-}
-
-function isBrowser(): boolean {
-  return typeof document !== 'undefined' && typeof Node !== 'undefined';
-}
-
-function isEventName(name: string): boolean {
-  return /^on[A-Z]/.test(name) || /^on[a-z]/.test(name);
-}
-
-function normalizeEventName(name: string): string {
-  return name.slice(2).toLowerCase();
-}
-
-function isRenderableObject(value: unknown): value is VElement | VFragment | Dynamic {
-  return !!value && typeof value === 'object' && 'kind' in value;
-}
-
-function normalizeChildren(children: unknown): Renderable[] {
-  if (children === undefined || children === null || children === false || children === true) return [];
-  if (Array.isArray(children)) return children.flatMap(normalizeChildren) as Renderable[];
-  return [children as Renderable];
-}
-
-function createComponentProps(raw: Props): Props {
-  const out: Props = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (isLazy(value)) {
-      Object.defineProperty(out, key, {
-        enumerable: true,
-        configurable: true,
-        get: () => value.fn()
-      });
-    } else {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-
-export function jsx(type: string | Component | typeof Fragment, props: Props | null): Renderable {
-  const finalProps = props ?? {};
-  if (type === Fragment) return createFragment(finalProps.children);
-  if (typeof type === 'function') return type(createComponentProps(finalProps));
-  if (isBrowser()) return createDomElement(type, finalProps);
-  return createVNode(type, finalProps);
-}
-
-export const jsxs = jsx;
-export const jsxDEV = jsx;
-
-function createFragment(children: unknown): Renderable {
-  const normalized = normalizeChildren(children);
-  if (isBrowser()) {
-    const fragment = document.createDocumentFragment();
-    appendChildren(fragment, normalized);
-    return fragment;
-  }
-  return { kind: 'fragment', children: normalized } satisfies VFragment;
-}
-
-function createVNode(tag: string, props: Props): VElement {
-  const children = normalizeChildren(props.children);
-  const elementProps: Props = { ...props };
-  delete elementProps.children;
-  return { kind: 'element', tag, props: elementProps, children };
-}
-
-function createDomElement(tag: string, props: Props): Element {
-  const element = tag === 'svg'
-    ? document.createElementNS('http://www.w3.org/2000/svg', tag)
-    : document.createElement(tag);
-
-  for (const [name, value] of Object.entries(props)) {
-    if (name === 'children') continue;
-    applyProp(element, name, value);
-  }
-  appendChildren(element, normalizeChildren(props.children));
-  return element;
-}
-
-function applyProp(element: Element, name: string, value: unknown): void {
-  if (name === 'ref') {
-    if (typeof value === 'function') (value as (node: Element) => void)(element);
-    return;
-  }
-  if (name === 'className') name = 'class';
-  if (name === 'classList' && value && typeof value === 'object') {
-    bindClassList(element, value as Record<string, unknown>);
-    return;
-  }
-  if (name === 'style' && value && typeof value === 'object' && !isLazy(value)) {
-    bindStyle(element as HTMLElement, value as Record<string, unknown>);
-    return;
-  }
-  if (isEventName(name)) {
-    const eventName = normalizeEventName(name);
-    if (isResumableHandler(value)) {
-      element.setAttribute(eventAttributeName(eventName), value.ref);
-      return;
-    }
-    if (typeof value !== 'function') return;
-    element.addEventListener(eventName, value as EventListener);
-    if (getOwner()) cleanup(() => element.removeEventListener(eventName, value as EventListener));
-    return;
-  }
-  if (isLazy(value)) {
-    effect(() => setDomProp(element, name, value.fn()));
-    return;
-  }
-  setDomProp(element, name, value);
-}
-
-function bindClassList(element: Element, classList: Record<string, unknown>): void {
-  for (const [className, active] of Object.entries(classList)) {
-    if (isLazy(active)) effect(() => element.classList.toggle(className, Boolean(active.fn())));
-    else element.classList.toggle(className, Boolean(active));
-  }
-}
-
-function bindStyle(element: HTMLElement, styles: Record<string, unknown>): void {
-  for (const [name, value] of Object.entries(styles)) {
-    const set = (next: unknown) => {
-      if (next === null || next === undefined || next === false) element.style.removeProperty(name);
-      else element.style.setProperty(name, String(next));
-    };
-    if (isLazy(value)) effect(() => set(value.fn()));
-    else set(value);
-  }
-}
-
-function setDomProp(element: Element, name: string, value: unknown): void {
-  if (value === false || value === null || value === undefined) {
-    element.removeAttribute(name);
-    if (name in element) {
-      try { (element as unknown as Record<string, unknown>)[name] = value === false ? false : ''; } catch {}
-    }
-    return;
-  }
-
-  if (value === true) {
-    element.setAttribute(name, '');
-    if (name in element) {
-      try { (element as unknown as Record<string, unknown>)[name] = true; } catch {}
-    }
-    return;
-  }
-
-  if (name === 'innerHTML' || name === 'outerHTML') {
-    throw new Error(`Blokd blocks direct ${name} assignment. Use text children or an explicit sanitization boundary.`);
-  }
-
-  if (name in element && !name.includes('-')) {
-    try {
-      (element as unknown as Record<string, unknown>)[name] = value;
-      return;
-    } catch {}
-  }
-  element.setAttribute(name, String(value));
-}
-
-function appendChildren(parent: Node, children: Renderable[]): void {
-  for (const child of children) appendChild(parent, child);
-}
-
-function appendChild(parent: Node, child: Renderable): void {
-  if (child === null || child === undefined || child === false || child === true) return;
-  if (Array.isArray(child)) {
-    for (const nested of child) appendChild(parent, nested);
-    return;
-  }
-  if (isLazy(child)) {
-    appendDynamic(parent, child.fn);
-    return;
-  }
-  if (isRenderableObject(child) && child.kind === 'dynamic') {
-    appendDynamic(parent, child.fn);
-    return;
-  }
-  if (typeof Node !== 'undefined' && child instanceof Node) {
-    parent.appendChild(child);
-    return;
-  }
-  parent.appendChild(document.createTextNode(String(child)));
-}
-
-function appendDynamic(parent: Node, fn: () => unknown): void {
-  const start = document.createComment('bd');
-  const end = document.createComment('/bd');
-  parent.appendChild(start);
-  parent.appendChild(end);
-  let disposers: Array<() => void> = [];
-
-  const clear = () => {
-    for (const dispose of disposers.splice(0)) dispose();
-    let node = start.nextSibling;
-    while (node && node !== end) {
-      const next = node.nextSibling;
-      node.parentNode?.removeChild(node);
-      node = next;
-    }
-  };
-
-  effect(() => {
-    clear();
-    const value = fn();
-    const nodes = materialize(value as Renderable, disposers);
-    for (const node of nodes) parent.insertBefore(node, end);
-  });
-
-  cleanup(clear);
-}
-
-function materialize(value: Renderable, disposers: Array<() => void>): Node[] {
-  if (value === null || value === undefined || value === false || value === true) return [];
-  if (Array.isArray(value)) return value.flatMap(item => materialize(item, disposers));
-  if (isLazy(value)) return materialize(value.fn() as Renderable, disposers);
-  if (isRenderableObject(value) && value.kind === 'dynamic') {
-    const fragment = document.createDocumentFragment();
-    root(dispose => {
-      disposers.push(dispose);
-      appendDynamic(fragment, value.fn);
-    });
-    return Array.from(fragment.childNodes);
-  }
-  if (typeof Node !== 'undefined' && value instanceof Node) return [value];
-  return [document.createTextNode(String(value))];
-}
-
-export function dynamic(fn: () => unknown): Dynamic | Node {
-  if (!isBrowser()) return { kind: 'dynamic', fn };
-  const fragment = document.createDocumentFragment();
-  appendDynamic(fragment, fn);
-  return fragment;
-}
-
-export function render(fn: () => Renderable, rootElement: Element | DocumentFragment): () => void {
-  rootElement.textContent = '';
-  return root(dispose => {
-    appendChild(rootElement, fn());
-    return dispose;
-  });
-}
-
-export function hydrate(fn: () => Renderable, rootElement: Element | DocumentFragment): () => void {
-  return render(fn, rootElement);
-}
-
-export function from(value: unknown): Renderable {
-  return value as Renderable;
-}