npm - @solidjs/web - Versions diffs - 2.0.0-beta.3 → 2.0.0-beta.30 - Mend

@solidjs/web 2.0.0-beta.3 → 2.0.0-beta.30

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (73) hide show

package/README.md +27 -4
package/dist/dev.cjs +1211 -205
package/dist/dev.js +1175 -199
package/dist/server.cjs +1342 -234
package/dist/server.js +1304 -231
package/dist/web.cjs +1195 -196
package/dist/web.js +1159 -190
package/frames/dist/client.cjs +1746 -0
package/frames/dist/client.dev.cjs +1759 -0
package/frames/dist/client.dev.js +1747 -0
package/frames/dist/client.js +1734 -0
package/frames/dist/server.cjs +2426 -0
package/frames/dist/server.js +2414 -0
package/frames/package.json +30 -0
package/package.json +287 -38
package/serialization/dist/serialization.cjs +169 -0
package/serialization/dist/serialization.js +159 -0
package/serialization/package.json +20 -0
package/serialization/types/index.d.ts +157 -0
package/serialization/types-cjs/index.d.cts +157 -0
package/serialization/types-cjs/package.json +3 -0
package/server-functions/dist/client.cjs +613 -0
package/server-functions/dist/client.js +585 -0
package/server-functions/dist/server.cjs +904 -0
package/server-functions/dist/server.js +875 -0
package/server-functions/package.json +30 -0
package/storage/package.json +8 -3
package/storage/types/index.d.ts +26 -0
package/storage/types-cjs/index.d.cts +28 -0
package/storage/types-cjs/package.json +3 -0
package/types/client.d.ts +125 -21
package/types/core.d.ts +4 -3
package/types/frames/client.d.ts +20 -0
package/types/frames/frame-client.d.ts +270 -0
package/types/frames/frame-sink.d.ts +168 -0
package/types/frames/frame-transport.d.ts +196 -0
package/types/frames/serializer.d.ts +157 -0
package/types/frames/server.d.ts +30 -0
package/types/index.d.ts +211 -26
package/types/jsx-properties.d.ts +93 -0
package/types/jsx.d.ts +4150 -1
package/types/response.d.ts +129 -0
package/types/serializer.d.ts +157 -0
package/types/server-functions/client.d.ts +200 -0
package/types/server-functions/flash.d.ts +38 -0
package/types/server-functions/server.d.ts +490 -0
package/types/server-functions/shared.d.ts +445 -0
package/types/server-mock.d.ts +93 -0
package/types/server.d.ts +221 -28
package/types-cjs/client.d.cts +192 -0
package/types-cjs/core.d.cts +4 -0
package/types-cjs/frames/client.d.cts +20 -0
package/types-cjs/frames/frame-client.d.cts +270 -0
package/types-cjs/frames/frame-sink.d.cts +168 -0
package/types-cjs/frames/frame-transport.d.cts +196 -0
package/types-cjs/frames/serializer.d.cts +157 -0
package/types-cjs/frames/server.d.cts +30 -0
package/types-cjs/index.d.cts +231 -0
package/types-cjs/jsx-properties.d.cts +93 -0
package/types-cjs/jsx.d.cts +4150 -0
package/types-cjs/package.json +3 -0
package/types-cjs/response.d.cts +129 -0
package/types-cjs/serializer.d.cts +157 -0
package/types-cjs/server-functions/client.d.cts +200 -0
package/types-cjs/server-functions/flash.d.cts +38 -0
package/types-cjs/server-functions/server.d.cts +490 -0
package/types-cjs/server-functions/shared.d.cts +445 -0
package/types-cjs/server-mock.d.cts +165 -0
package/types-cjs/server.d.cts +349 -0
package/storage/types/src/client.d.ts +0 -1
package/storage/types/src/index.d.ts +0 -46
package/storage/types/src/server-mock.d.ts +0 -72
package/storage/types/storage/src/index.d.ts +0 -2

package/types/server.d.ts CHANGED Viewed

@@ -1,22 +1,82 @@
 import { JSX } from "./jsx.js";
-export const Properties: Set<string>;
+import { SerializerPlugin } from "./serializer.js";
+export const DOMWithState: Record<string, Record<string, 1 | 2>>;
 export const ChildProperties: Set<string>;
 export const DelegatedEvents: Set<string>;
 export const DOMElements: Set<string>;
 export const SVGElements: Set<string>;
-export const SVGNamespace: Record<string, string>;
+export const MathMLElements: Set<string>;
+export const VoidElements: Set<string>;
+export const RawTextElements: Set<string>;
+export const Namespaces: Record<string, string>;
 type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
+/** Static asset manifest produced by a build (e.g. parsed Vite manifest.json). */
+export type AssetManifest = Record<
+  string,
+  { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
+> & { _base?: string };
+/** Inline style content, e.g. dev CSS collected from a bundler's module graph. */
+export type InlineStyleAsset = {
+  id: string;
+  content: string;
+  attrs?: Record<string, string>;
+};
+export type ResolvedAssets = {
+  js: string[];
+  css: (string | InlineStyleAsset)[];
+};
+/**
+ * Resolver form of the manifest option — the primitive a dev server
+ * implements against its live module graph (a static manifest object is
+ * normalized into a sync resolver internally). `resolve` may return a
+ * promise (async resolvers require streaming rendering); CSS entries may be
+ * URL strings (emitted as load-gated `<link>` tags) or inline-style
+ * descriptors (emitted as `<style>` tags). A bare `resolve`-shaped function
+ * is accepted as shorthand for `{ resolve }`.
+ */
+export type AssetResolver = {
+  resolve(
+    key: string
+  ): ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
+  /**
+   * Synchronous fast path answering with whatever is knowable without async
+   * work (typically js URLs, omitting css). Sync consumers — e.g. a lazy
+   * component's `moduleUrl` getter used by islands — use this when `resolve`
+   * would return a promise, so adapters should provide it whenever possible.
+   */
+  resolveSync?(key: string): ResolvedAssets | null | undefined;
+};
+/** Bare-function shorthand for `AssetResolver` (no sync fast path). */
+export type AssetResolverFn = (
+  key: string
+) => ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
 export function renderToString<T>(
   fn: () => T,
   options?: {
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<string, { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }> & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onError?: (err: any) => void;
+    /**
+     * Embedded-render contract for hosts that own the document. When the
+     * render output contains no `</head>`, everything head-bound (resolved
+     * `useHead` winners, eager resources, tracked asset links, inline
+     * styles) is delivered here as one HTML string — prelude (charset/base)
+     * first — for the host to splice into its own `<head>` template, instead
+     * of being dropped. Called synchronously before `renderToString`
+     * returns; not called when the output has a `</head>` (splicing is
+     * automatic then).
+     */
+    onHead?: (head: string) => void;
   }
 ): string;
 /** @deprecated use renderToStream which also returns a promise */
@@ -27,8 +87,8 @@ export function renderToStringAsync<T>(
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<string, { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }> & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onError?: (err: any) => void;
   }
 ): Promise<string>;
@@ -38,16 +98,38 @@ export function renderToStream<T>(
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<string, { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }> & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onCompleteShell?: (info: { write: (v: string) => void }) => void;
     onCompleteAll?: (info: { write: (v: string) => void }) => void;
     onError?: (err: any) => void;
+    /**
+     * Embedded-render contract for hosts that own the document. When the
+     * shell contains no `</head>`, everything head-bound at first flush
+     * (resolved `useHead` winners, eager resources, tracked asset links,
+     * inline styles) is delivered here as one HTML string — prelude first —
+     * before the shell chunk is emitted, so the host can write its own
+     * `<head>` ahead of piping the stream. Post-shell head updates flow
+     * through the stream itself and apply in the browser. Not called when
+     * the shell has a `</head>` (splicing is automatic then).
+     */
+    onHead?: (head: string) => void;
   }
 ): {
   then: (fn: (html: string) => void) => void;
   pipe: (writable: { write: (v: string) => void; end: () => void }) => void;
   pipeTo: (writable: WritableStream) => Promise<void>;
+  /**
+   * Lazy `ReadableStream<Uint8Array>` view of the render — hand it straight
+   * to `new Response(stream.readable)`. First access starts the render
+   * piping through an internal `TransformStream` (chunks are UTF-8 encoded
+   * bytes, the same as `pipeTo` writes) and the stream is cached, so
+   * repeated access returns the same instance. Like `pipe`/`pipeTo`, this
+   * consumes the render: use exactly one of the three — mixing distinct
+   * consumers (`readable` after `pipe`/`pipeTo`, or vice versa) throws an
+   * error naming the conflict.
+   */
+  readonly readable: ReadableStream<Uint8Array>;
 };
 export function HydrationScript(props: { nonce?: string; eventNames?: string[] }): JSX.Element;
@@ -62,25 +144,105 @@ export function ssrClassName(value: string | { [k: string]: boolean } | Array<an
 export function ssrStyle(value: string | { [k: string]: string }): string;
 export function ssrStyleProperty(name: string, value: any): string;
 export function ssrAttribute(key: string, value: any): string;
+export function ssrGroup<T extends () => any[]>(fn: T, n: number): T;
+export function scope<T>(fn: () => T): () => unknown;
 export function ssrHydrationKey(): string;
 export function resolveSSRNode(node: any, result?: any, top?: boolean): any;
 export function escape(s: any, attr?: boolean): any;
-export function applyRef(r: ((element: any) => void) | ((element: any) => void)[], element: any): void;
+export function applyRef(
+  r: ((element: any) => void) | ((element: any) => void)[],
+  element: any
+): void;
+/** @deprecated Use `useHead` — removed before `0.50.0` stable. */
 export function useAssets(fn: () => JSX.Element): void;
+/**
+ * @deprecated Use the `onHead` render option — removed before `0.50.0`
+ * stable. Reads ambient render state, so it is unsafe across concurrent
+ * renders; `onHead` is closure-bound to its render and also carries
+ * `useHead` output, which this does not.
+ */
 export function getAssets(): string;
+/**
+ * A head tag descriptor. Props values may be getters (evaluated lazily on
+ * the server — at the owning flush boundary — and reactively on the client);
+ * `children` is the text body (title text, inline style/script content).
+ * `key` overrides the built-in dedupe identity (`title` is a hard singleton
+ * that `key` cannot fork).
+ */
+export type HeadTag = {
+  tag: "title" | "meta" | "link" | "style" | "script" | "base";
+  props: Record<string, any>;
+  key?: string | (() => string);
+};
+/**
+ * Registers head tags with the render's head registry. An array is a group —
+ * one replacement set; a single tag is a group of one. Replaceable tags
+ * (title/meta/canonical/…) resolve by last-committed group and stream as
+ * patches with their suspense boundary's reveal; resource tags (preload and
+ * friends, stylesheets, `script[src]`) emit eagerly and dedupe by identity.
+ * See docs/head-management-rfc.md.
+ */
+export function useHead(tag: HeadTag | HeadTag[]): void;
 export function getHydrationKey(): string | undefined;
-export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void, init?: T): void;
+export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
 export function memo<T>(fn: () => T, equal: boolean): () => T;
 export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
 export function mergeProps(...sources: unknown[]): unknown;
 export function getOwner(): unknown;
-export function ssrRunInScope(fn: () => void, owner: unknown): void;
-export function generateHydrationScript(options?: { nonce?: string; eventNames?: string[] }): string;
+export function generateHydrationScript(options?: {
+  nonce?: string;
+  eventNames?: string[];
+}): string;
+/**
+ * Registered symbol (`Symbol.for("solid.RequestContext")`) naming the
+ * global slot where `provideRequestEvent` parks the AsyncLocalStorage that
+ * scopes request events. Integration plumbing — application code reads the
+ * event through `getRequestEvent()` instead.
+ * @internal
+ */
 export declare const RequestContext: unique symbol;
+/**
+ * The mutable response head an integration's handler exposes on the request
+ * event as `event.response`: status/statusText/headers it will apply when
+ * sending the response. A scaffold, not a `Response` — application code
+ * (e.g. JSX response components) writes to it during render, and the
+ * handler reads it when the head goes out. Core does not declare the
+ * `response` property on `RequestEvent` itself: integrations that provide
+ * one declare it through module augmentation (as `@solidjs/router` does),
+ * and this type names the shape they agree on. Core's server-function
+ * handler reads its `Set-Cookie` headers when folding single-flight
+ * cookies but never requires it.
+ */
+export interface ResponseStub {
+  status?: number;
+  statusText?: string;
+  headers: Headers;
+  /**
+   * Set by the integration once the response head has been derived/sent
+   * from this stub — status and headers can no longer change. Consumers
+   * that write response metadata during render (e.g. JSX response
+   * components) must treat later status/header writes and cleanup-time
+   * retractions as no-ops.
+   */
+  committed?: boolean;
+}
+/**
+ * The per-request context available on the server: the incoming `Request`
+ * and a `locals` bag integrations and middleware can hang state on.
+ * Frameworks typically extend this shape with richer fields (e.g. a
+ * `response` head — see `ResponseStub`).
+ */
 export interface RequestEvent {
   request: Request;
   locals: Record<string | number | symbol, any>;
 }
+/**
+ * The current request event, when called on the server inside a request
+ * scope (established by `provideRequestEvent` from `@solidjs/web/storage`
+ * or by the framework). Undefined on the client and outside a request.
+ * Read it above `await` boundaries in partially-polyfilled environments.
+ */
 export function getRequestEvent(): RequestEvent | undefined;
 export function Assets(props: { children?: JSX.Element }): JSX.Element;
@@ -104,15 +266,26 @@ export function insert<T>(
 ): JSX.Element;
 /** @deprecated not supported on the server side */
-export function spread<T>(
-  node: Element,
-  accessor: T,
-  isSVG?: Boolean,
-  skipChildren?: Boolean
-): void;
+export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
 /** @deprecated not supported on the server side */
-export function delegateEvents(eventNames: string[], d?: Document): void;
+export function delegateEvents(eventNames: string[]): void;
+/** @deprecated not supported on the server side */
+export function registerDelegatedRoot(root: MountableElement): void;
+/** @deprecated not supported on the server side */
+export function unregisterDelegatedRoot(root: MountableElement): void;
+/** @deprecated not supported on the server side */
+export function registerDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+/** @deprecated not supported on the server side */
+export function unregisterDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+/** @deprecated not supported on the server side */
+export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
 /** @deprecated not supported on the server side */
 export function dynamicProperty(props: unknown, key: string): unknown;
 /** @deprecated not supported on the server side */
@@ -120,24 +293,35 @@ export function setAttribute(node: Element, name: string, value: string): void;
 /** @deprecated not supported on the server side */
 export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
+/**
+ * Server no-op: element claims are a client-only concern, but consumers may
+ * register isomorphically. Returns a no-op unregister function.
+ */
+export function registerElementClaim(handler: (element: Element) => void): () => void;
+/** Server no-op: returns `node` unchanged. Claims never fire during SSR. */
+export function claimElement<T extends Element>(node: T): T;
+/** Server no-op: returns `root` unchanged. Claims never fire during SSR. */
+export function claimElementTree<T extends Node>(root: T): T;
 /** @deprecated not supported on the server side */
-export function addEventListener(
-  node: Element,
-  name: string,
-  handler: () => void,
-  delegate: boolean
-): void;
+export function addEvent(node: Element, name: string, handler: () => void, delegate: boolean): void;
 /** @deprecated not supported on the server side */
 export function render(code: () => JSX.Element, element: MountableElement): () => void;
-/** @deprecated not supported on the server side */
-export function template(html: string, isImportNode?: boolean, isSVG?: boolean, isMathML?: boolean): () => Element;
+/**
+ * @deprecated not supported on the server side
+ * @param flag
+ * - `undefined` — clone the template as-is (uses `cloneNode`).
+ * - `1` — use `document.importNode` instead of `cloneNode`.
+ * - `2` — the template html is wrapped; the outer tag is stripped at clone time.
+ */
+export function template(html: string, flag?: 1 | 2): () => Element;
 /** @deprecated not supported on the server side */
 export function setProperty(node: Element, name: string, value: any): void;
 /** @deprecated not supported on the server side */
 export function className(node: Element, value: string): void;
 /** @deprecated not supported on the server side */
-export function assign(node: Element, props: any, isSVG?: Boolean, skipChildren?: Boolean): void;
+export function assign(node: Element, props: any, skipChildren?: Boolean): void;
 /** @deprecated not supported on the server side */
 export function hydrate(
@@ -154,3 +338,12 @@ export function getNextMatch(start: Node, elementName: string): Element;
 export function getNextMarker(start: Node): [Node, Array<Node>];
 /** @deprecated not supported on the server side */
 export function runHydrationEvents(): void;
+/** @deprecated not supported on the server side */
+export function ref(
+  fn: () => ((element: Element) => void) | ((element: Element) => void)[],
+  element: Element
+): void;
+/** @deprecated not supported on the server side */
+export function setStyleProperty(node: Element, name: string, value: any): void;
+/** @deprecated not supported on the server side — register assets through the render context instead */
+export function acquireAsset(descriptor: unknown): () => void;

package/types-cjs/client.d.cts ADDED Viewed

@@ -0,0 +1,192 @@
+import { JSX } from "./jsx.cjs";
+export const DOMWithState: Record<string, Record<string, 1 | 2>>;
+export const ChildProperties: Set<string>;
+export const DelegatedEvents: Set<string>;
+export const DOMElements: Set<string>;
+export const SVGElements: Set<string>;
+export const MathMLElements: Set<string>;
+export const VoidElements: Set<string>;
+export const RawTextElements: Set<string>;
+export const Namespaces: Record<string, string>;
+type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
+export function render(
+  code: () => JSX.Element,
+  element: MountableElement,
+  init?: JSX.Element,
+  options?: { owner?: unknown }
+): () => void;
+/**
+ * @param flag
+ * - `undefined` — clone the template as-is (uses `cloneNode`).
+ * - `1` — use `document.importNode` instead of `cloneNode`.
+ * - `2` — the template html is wrapped; the outer tag is stripped at clone time.
+ */
+export function template(html: string, flag?: 1 | 2): () => Element;
+export function scope<T extends () => any>(fn: T): T;
+export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
+export function memo<T>(fn: () => T, equal: boolean): () => T;
+export function untrack<T>(fn: () => T): T;
+export function insert<T>(
+  parent: MountableElement,
+  accessor: (() => T) | T,
+  marker?: Node | null,
+  init?: JSX.Element,
+  options?: {
+    /**
+     * Live accessor for the slot's logical host in the source tree (portals).
+     * Each top-level node the slot manages is tagged with a `_$host` getter
+     * backed by this accessor so delegated events retarget correctly.
+     */
+    host?: () => Node | null;
+    /** Defer the insert effect to the queue instead of running it inline. */
+    schedule?: boolean;
+  }
+): JSX.Element;
+export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
+export function delegateEvents(eventNames: string[]): void;
+export function registerDelegatedRoot(root: MountableElement): void;
+export function unregisterDelegatedRoot(root: MountableElement): void;
+export function registerDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+export function unregisterDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
+export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
+export function assign(
+  node: Element,
+  props: any,
+  skipChildren?: Boolean,
+  prevProps?: any,
+  skipRef?: Boolean
+): void;
+export function setAttribute(node: Element, name: string, value: string): void;
+export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
+/**
+ * Register a consumer for compiler-emitted element claims. Compiled DOM
+ * output claims navigation-relevant elements (`a[href]`, `form[action]`) at
+ * creation, and compiler-owned writes to `href`/`action` re-invoke the same
+ * handlers — so handlers must be idempotent and must check the element's
+ * relevance themselves (rechecks can fire for any element whose
+ * `href`/`action` is written, e.g. `<link href>`). Handlers run under the
+ * reactive owner current at element creation; scope per-element state and
+ * cleanup through your own reactive system. Dormant until registered —
+ * without a handler the emitted claims are null checks. Returns an
+ * unregister function.
+ */
+export function registerElementClaim(handler: (element: Element) => void): () => void;
+/**
+ * Claim `node` for registered consumers (see `registerElementClaim`).
+ * Emitted by the compiler at element creation; idempotent by contract.
+ */
+export function claimElement<T extends Element>(node: T): T;
+/**
+ * Sweep-claim every navigation-relevant element (`a[href]`, `form[action]`)
+ * in `root` — the subtree equivalent of the per-element `claimElement`
+ * compiled output emits, for content that becomes live DOM without compiled
+ * creation code (frame streams, adopted SSR ranges). Dormant without a
+ * registered consumer.
+ */
+export function claimElementTree<T extends Node>(root: T): T;
+export function className(node: Element, value: JSX.ClassValue, prev?: JSX.ClassValue): void;
+export function setProperty(node: Element, name: string, value: any): void;
+export function setStyleProperty(node: Element, name: string, value: any): void;
+export function addEvent(
+  node: Element,
+  name: string,
+  handler: EventListener | EventListenerObject | (EventListenerObject & AddEventListenerOptions),
+  delegate: boolean
+): void;
+export function style(
+  node: Element,
+  value: { [k: string]: string },
+  prev?: { [k: string]: string }
+): void;
+export function getOwner(): unknown;
+export function mergeProps(...sources: unknown[]): unknown;
+export function dynamicProperty(props: unknown, key: string): unknown;
+export function applyRef<T extends Element = Element>(
+  r: ((element: NoInfer<T>) => void) | ((element: NoInfer<T>) => void)[],
+  element: T
+): void;
+export function ref(
+  fn: () => ((element: Element) => void) | ((element: Element) => void)[],
+  element: Element
+): void;
+export function hydrate(
+  fn: () => JSX.Element,
+  node: MountableElement,
+  options?: { renderId?: string; owner?: unknown }
+): () => void;
+export function getHydrationKey(): string | undefined;
+export function getNextElement(template?: () => Element): Element;
+export function getNextMatch(start: Node, elementName: string): Element;
+export function getNextMarker(start: Node): [Node, Array<Node>];
+/** @deprecated Use `useHead` — removed before `0.50.0` stable. */
+export function useAssets(fn: () => JSX.Element): void;
+/** @deprecated Use `useHead` — removed before `0.50.0` stable. */
+export function getAssets(): string;
+/**
+ * A head tag descriptor. Props values may be getters (reactive on the
+ * client); `children` is the text body. `key` overrides the built-in dedupe
+ * identity (`title` is a hard singleton that `key` cannot fork).
+ */
+export type HeadTag = {
+  tag: "title" | "meta" | "link" | "style" | "script" | "base";
+  props: Record<string, any>;
+  key?: string | (() => string);
+};
+/**
+ * Registers head tags with the ambient head registry under the current
+ * owner. An array is a group — one replacement set. Resolution is
+ * last-committed group per identity; disposal restores the previous winner.
+ * During hydration the server-flushed head state stays authoritative until
+ * hydration completes. See docs/head-management-rfc.md.
+ */
+export function useHead(tag: HeadTag | HeadTag[]): void;
+export type AssetDescriptor =
+  | { type: "style"; href: string; attrs?: Record<string, string> }
+  | { type: "inline-style"; id: string; content?: string; attrs?: Record<string, string> }
+  | { type: "module"; href: string }
+  | ExclusiveAssetDescriptor<any>;
+export interface ExclusiveAssetDescriptor<T> {
+  policy: "exclusive";
+  key: string;
+  value: T;
+  get(): T;
+  set(value: T): void;
+}
+export function acquireAsset(descriptor: AssetDescriptor): () => void;
+export function HydrationScript(props?: { nonce?: string; eventNames?: string[] }): JSX.Element;
+export function generateHydrationScript(options?: {
+  nonce?: string;
+  eventNames?: string[];
+}): string;
+export function Assets(props: { children?: JSX.Element }): JSX.Element;
+/**
+ * See the server entry's `ResponseStub` — the shape of the mutable response
+ * head integrations expose as `event.response` via module augmentation.
+ */
+export interface ResponseStub {
+  status?: number;
+  statusText?: string;
+  headers: Headers;
+  /**
+   * Set by the integration once the response head has been derived/sent
+   * from this stub (status/headers can no longer change); consumers must
+   * treat later writes and cleanup-time retractions as no-ops.
+   */
+  committed?: boolean;
+}
+export interface RequestEvent {
+  request: Request;
+  locals: Record<string | number | symbol, any>;
+}
+export declare const RequestContext: unique symbol;
+export function getRequestEvent(): RequestEvent | undefined;
+export function runHydrationEvents(): void;

package/types-cjs/core.d.cts ADDED Viewed

@@ -0,0 +1,4 @@
+export { getOwner, runWithOwner, createComponent, createRoot as root, sharedConfig, untrack, merge as mergeProps, flatten, ssrHandleError, ssrScope, NoHydration, Hydration, runInServerComponentScope } from "solid-js";
+export declare const effect: (fn: any, effectFn: any, options: any) => void;
+export declare const memo: (fn: any) => import("solid-js").SourceAccessor<any>;
+export declare const runWithHydrationScope: (id: any, fn: any) => unknown;

package/types-cjs/frames/client.d.cts ADDED Viewed

@@ -0,0 +1,20 @@
+export { createFrame, createFrameHost, createFrameElement, FRAME_APPLIED_EVENT } from "./frame-client.cjs";
+export { FRAME_STREAM_HEADER, applyFrameResponse, isFrameStreamResponse, createServerComponentHandler } from "./frame-transport.cjs";
+export { createJSONDataTable } from "./serializer.cjs";
+export type { Slot } from "./server.cjs";
+export declare function getFrameHost(): any;
+/**
+ * Installs the server-component transport policy on the server-function
+ * client: boundary identity is the call's intrinsic (function, arguments)
+ * address — per-args, exactly like the query cache, so a cached component
+ * always mounts the boundary showing the call it was cached for. Repeat
+ * calls for the same args resolve the identical component (refetches morph
+ * in place, cache hits pass `dynamic`'s equals-gate); a source switching
+ * args swaps boundaries, re-materialized instantly from the host's
+ * retained state.
+ *
+ * Call once in the client entry (an explicit call — the package is
+ * `sideEffects: false`, so a bare import would be tree-shaken away);
+ * call again to rebind to a custom host.
+ */
+export declare function installServerComponents(host?: any): void;