@solidjs/web 2.0.0-rc.2 → 2.0.0-rc.3

package/types/client.d.ts

@@ -1,199 +1,8 @@
+import { getOwner, createComponent, untrack, merge as mergeProps } from "solid-js";
+import { effect, memo } from "./render.js";
 import { JSX } from "./jsx.js";
 import type { RequestEventLocals } from "./server.js";
-// Element/property classification tables consumed by the JSX compiler and
-// custom renderers. Compiler/tooling surface; not for hand-written code.
-/** Compiler/tooling table; not for hand-written code. @internal */
-export const DOMWithState: Record<string, Record<string, 1 | 2>>;
-/** Compiler/tooling table; not for hand-written code. @internal */
-export const ChildProperties: Set<string>;
-/** Compiler/tooling table; not for hand-written code. @internal */
-export const DelegatedEvents: Set<string>;
-/** Compiler/tooling table; not for hand-written code. @internal */
-export const DOMElements: Set<string>;
-/** Compiler/tooling table; not for hand-written code. @internal */
-export const SVGElements: Set<string>;
-/** Compiler/tooling table; not for hand-written code. @internal */
-export const MathMLElements: Set<string>;
-/** Compiler/tooling table; not for hand-written code. @internal */
-export const VoidElements: Set<string>;
-/** Compiler/tooling table; not for hand-written code. @internal */
-export const RawTextElements: Set<string>;
-/** Compiler/tooling table; not for hand-written code. @internal */
-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;
-/**
- * Compiler-emitted primitive; not for hand-written code.
- * @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.
- * @internal
- */
-export function template(html: string, flag?: 1 | 2): () => Element;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function scope<T extends () => any>(fn: T): T;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function memo<T>(fn: () => T, equal: boolean): () => T;
-/**
- * Compiler-emitted primitive; not for hand-written code — import `untrack`
- * from `solid-js` instead.
- * @internal
- */
-export function untrack<T>(fn: () => T): T;
-/**
- * Compiler-emitted primitive; not for hand-written code.
- * @internal
- */
-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;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function delegateEvents(eventNames: string[]): void;
-/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
-export function registerDelegatedRoot(root: MountableElement): void;
-/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
-export function unregisterDelegatedRoot(root: MountableElement): void;
-/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
-export function registerDelegatedContainer(
-  container: MountableElement,
-  owner?: MountableElement
-): void;
-/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
-export function unregisterDelegatedContainer(
-  container: MountableElement,
-  owner?: MountableElement
-): void;
-/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
-export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function assign(
-  node: Element,
-  props: any,
-  skipChildren?: Boolean,
-  prevProps?: any,
-  skipRef?: Boolean
-): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function setAttribute(node: Element, name: string, value: string): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-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.
- *
- * Integration plumbing (routers register the consumer); not meant for
- * application code.
- * @internal
- */
-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.
- * @internal
- */
-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.
- *
- * Integration plumbing; not meant for application code.
- * @internal
- */
-export function claimElementTree<T extends Node>(root: T): T;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function className(node: Element, value: JSX.ClassValue, prev?: JSX.ClassValue): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function setProperty(node: Element, name: string, value: any): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function setStyleProperty(node: Element, name: string, value: any): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function addEvent(
-  node: Element,
-  name: string,
-  handler: EventListener | EventListenerObject | (EventListenerObject & AddEventListenerOptions),
-  delegate: boolean
-): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function style(
-  node: Element,
-  value: { [k: string]: string },
-  prev?: { [k: string]: string }
-): void;
-/**
- * Compiler-emitted primitive; not for hand-written code — import `getOwner`
- * from `solid-js` instead.
- * @internal
- */
-export function getOwner(): unknown;
-/**
- * Compiler-emitted prop-spread helper; not for hand-written code — import
- * `merge` from `solid-js` instead.
- * @internal
- */
-export function mergeProps(...sources: unknown[]): unknown;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function dynamicProperty(props: unknown, key: string): unknown;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-export function applyRef<T extends Element = Element>(
-  r: ((element: NoInfer<T>) => void) | ((element: NoInfer<T>) => void)[],
-  element: T
-): void;
-/** Compiler-emitted primitive; not for hand-written code. @internal */
-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;
-/** Hydration-walk primitive; not for hand-written code. @internal */
-export function getHydrationKey(): string | undefined;
-/** Hydration-walk primitive; not for hand-written code. @internal */
-export function getNextElement(template?: () => Element): Element;
-/** Hydration-walk primitive; not for hand-written code. @internal */
-export function getNextMatch(start: Node, elementName: string): Element;
-/** Hydration-walk primitive; not for hand-written code. @internal */
-export function getNextMarker(start: Node): [Node, Array<Node>];
 /**
  * A head tag descriptor. Props values may be getters (reactive on the
  * client); `children` is the text body. `key` overrides the built-in dedupe
@@ -207,42 +16,30 @@ export function getNextMarker(start: Node): [Node, Array<Node>];
  * read them from the getter. See docs/head-management-rfc.md.
  */
 export type HeadTag = {
-  tag: "title" | "meta" | "link" | "style" | "script" | "base";
-  props: Record<string, any>;
-  key?: string | (() => string);
+    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; a function is a
- * reactive group whose membership is tracked and re-read on change.
- * Resolution is last-committed group per identity (reactive updates keep
- * the registration's original commit position); 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[] | (() => 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 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;
+    policy: "exclusive";
+    key: string;
+    value: T;
+    get(): T;
+    set(value: T): void;
 }
-/**
- * @internal Ref-counted client asset ownership: acquire adopts or mounts the
- * asset, the returned release follows the owner (with a grace period for
- * back-and-forth navigation). Internal machinery, not a public CSS-lifecycle
- * API — per the head-management RFC (docs/head-management-rfc.md), ambient
- * bundler-injected CSS is never lifecycle-managed, and the head registry
- * owns the lifecycle of directly-mounted stylesheets outright. This keeps
- * its non-head roles (exclusive slots, owner-following DOM ownership).
- */
-export function acquireAsset(descriptor: AssetDescriptor): () => void;
 /**
  * Registry entry returned by `warmAsset`. Stylesheet entries carry load
  * tracking for the client reveal gate (docs/client-css-reveal-gating.md):
@@ -250,38 +47,23 @@ export function acquireAsset(descriptor: AssetDescriptor): () => void;
  * sheet releases the gate, parity with the server gate.
  */
 export interface AssetEntry {
-  loadState?: "pending" | "loaded" | "errored";
-  loadPromise?: Promise<void>;
+    loadState?: "pending" | "loaded" | "errored";
+    loadPromise?: Promise<void>;
 }
-/**
- * @internal Warm half of `acquireAsset`: idempotent and refcount-free,
- * callable from a compute phase so the fetch starts at discovery and
- * overlaps a transition's data wait. Stylesheets warm as
- * `rel="preload" as="style"` and are flipped live by `acquireAsset` at
- * commit — a branch superseded before it commits leaks only an inert
- * preload, never an applied sheet. Only link-backed descriptors warm;
- * inline styles and exclusive slots return `undefined`.
- */
-export function warmAsset(descriptor: AssetDescriptor): AssetEntry | undefined;
-export function HydrationScript(props?: { nonce?: string; eventNames?: string[] }): JSX.Element;
-export function generateHydrationScript(options?: {
-  nonce?: string;
-  eventNames?: string[];
-}): string;
 /**
  * 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;
+    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;
 }
 /**
  * See the server entry's `RequestEventLocals` — the augmentable type of
@@ -291,47 +73,125 @@ export interface ResponseStub {
  */
 export { RequestEventLocals } from "./server.js";
 export interface RequestEvent {
-  request: Request;
-  locals: RequestEventLocals;
+    request: Request;
+    locals: RequestEventLocals;
 }
-/**
- * Registered symbol (`Symbol.for("solid.RequestContext")`) naming the global
- * slot where `provideRequestEvent` parks the AsyncLocalStorage scoping
- * request events. Integration plumbing — read the event through
- * `getRequestEvent()` instead.
+export type { CookieOptions } from "./cookies.js";
+export type { ServerFunction, ServerFunctionMetadata, ServerFunctionRPC } from "./server-functions/shared.js";
+export declare const waitAsset: (promise: Promise<unknown>) => void;
+export { DOMWithState, ChildProperties, DOMElements, SVGElements, MathMLElements, VoidElements, RawTextElements, Namespaces, DelegatedEvents } from "./constants.js";
+/** Client stub — hydration bootstrap is a server-only emit. */
+export declare function generateHydrationScript(_options?: {
+    eventNames?: string[];
+    nonce?: string;
+}): string;
+/** Client stub — valid JSX component, renders nothing. */
+export declare function HydrationScript(_props?: {
+    nonce?: string;
+    eventNames?: string[];
+}): null;
+export { effect, memo, untrack, getOwner, createComponent };
+/**
+ * Compiler-emitted prop-spread helper. The JSX transform emits
+ * `mergeProps(...)` when compiling prop spreads on components — not a
+ * user-facing API. Application code should import `merge` from `solid-js`.
  * @internal
  */
-export declare const RequestContext: unique symbol;
-export function getRequestEvent(): RequestEvent | undefined;
-/**
- * The cookie codec (the platform-gap primitives — see cookies.d.ts for the
- * blessed patterns): the real implementation on both entries, never a
- * stub — a pure value transformer has legitimate browser uses
- * (`document.cookie`). Tree-shakes away when unused.
- */
+export { mergeProps };
+export declare const getRequestEvent: () => RequestEvent | undefined;
 export { parseCookieHeader, serializeCookie } from "./cookies.js";
-export type { CookieOptions } from "./cookies.js";
+export { clearFlashCookie, hasFlashCookie } from "./cookies.js";
+export { getServerFunctionMetadata, getServerFunctionRPC, isServerFunction } from "./server-functions/registry.js";
 /**
- * The flash cookie's isomorphic half (name/detection/clearing — cookie
- * utilities living beside the cookie codec) and the codec-free
- * server-function layer (reference detection + the late-bound RPC seam).
- * On the core entries so integrations consuming them eagerly (routers)
- * never import the server-functions entry — whose client half is the
- * transport + codec — from their eager graph. Declared through
- * server-functions/shared.d.ts, the declaration home published-types
- * layouts ship.
+ * Renders a component tree into a DOM element. Returns a dispose function
+ * that tears the tree down and cleans up reactive scopes when called.
+ *
+ * The top-level insert is queued via `{ schedule: true }` so its initial
+ * DOM attach goes through the effect queue rather than executing inline.
+ * This lets the mount participate in transitions: if an uncaught async
+ * read surfaces during the initial render (no `Loading` ancestor absorbs
+ * it), the mount is held by the transition and attaches atomically once
+ * all pending settles. On the no-async happy path the tail `flush()`
+ * drains the queued callback so the attach is synchronous by the time
+ * `render()` returns. The dev enforcement window scopes
+ * `ASYNC_OUTSIDE_LOADING_BOUNDARY` to the initial mount only.
+ */
+export declare function render(code: () => JSX.Element, element: MountableElement, init?: JSX.Element, options?: {
+    owner?: unknown;
+    renderId?: string;
+}): () => void;
+export declare function template(html: string, flag?: 1 | 2): () => Element;
+export declare function delegateEvents(eventNames: string[]): void;
+export declare function registerDelegatedRoot(root: MountableElement): void;
+export declare function unregisterDelegatedRoot(root: MountableElement): void;
+export declare function registerDelegatedContainer(container: MountableElement, owner?: MountableElement): void;
+export declare function unregisterDelegatedContainer(container: MountableElement, owner?: MountableElement): void;
+export declare function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
+export declare function setProperty(node: Element, name: string, value: any): void;
+export declare function registerElementClaim(handler: (element: Element) => void): () => void;
+export declare function claimElementTree<T extends Node>(root: T): T;
+export declare function claimElement<T extends Element>(node: T): T;
+export declare function setAttribute(node: Element, name: string, value: string): void;
+export declare function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
+export declare function className(node: Element, value: JSX.ClassValue, prev?: JSX.ClassValue): void;
+export declare function addEvent(node: Element, name: string, handler: EventListener | EventListenerObject | (EventListenerObject & AddEventListenerOptions), delegate: boolean): void;
+export declare function style(node: Element, value: {
+    [k: string]: string;
+}, prev?: {
+    [k: string]: string;
+}): void;
+export declare function setStyleProperty(node: Element, name: string, value: any): void;
+export declare function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
+export declare function dynamicProperty(props: unknown, key: string): unknown;
+export declare function applyRef<T extends Element = Element>(r: ((element: NoInfer<T>) => void) | ((element: NoInfer<T>) => void)[], element: T): void;
+export declare function ref(fn: () => ((element: Element) => void) | ((element: Element) => void)[], element: Element): void;
+export declare function rowProof(fn: any): any; /** Compiler-emitted primitive; not for hand-written code. @internal */
+export declare function scope<T extends () => any>(fn: T): T;
+export declare function installHydrationRuntime(): void;
+export declare function patchDriver(subject: any, body: any): void; /**
+ * Compiler-emitted primitive; not for hand-written code.
+ * @internal
  */
-export {
-  clearFlashCookie,
-  getServerFunctionMetadata,
-  getServerFunctionRPC,
-  hasFlashCookie,
-  isServerFunction
-} from "./server-functions/shared.js";
-export type {
-  ServerFunction,
-  ServerFunctionMetadata,
-  ServerFunctionRPC
-} from "./server-functions/shared.js";
-/** Hydration-walk primitive; not for hand-written code. @internal */
-export function runHydrationEvents(): void;
+export declare 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 declare function assign(node: Element, props: any, skipChildren?: Boolean, prevProps?: any, skipRef?: Boolean): void;
+export declare function warmAsset(descriptor: AssetDescriptor): AssetEntry | undefined;
+export declare function acquireAsset(descriptor: AssetDescriptor): () => void;
+export declare function useHead(tag: HeadTag | HeadTag[] | (() => HeadTag | HeadTag[])): void;
+/**
+ * Resumes a server-rendered tree on the client, attaching event listeners
+ * and reactive bindings without reconstructing the DOM. Returns a `dispose`
+ * function that tears down reactive scopes (DOM nodes are left in place).
+ *
+ * Use this when the page HTML was produced by `renderToString` or
+ * `renderToStream`. For client-only apps, use `render` instead.
+ *
+ * Pass `options.renderId` to hydrate one of multiple roots emitted by a
+ * server render that used the same id.
+ *
+ * When the server renders a full document but the client hydrates only the
+ * app subtree, the server must give that subtree its own id namespace: wrap
+ * the document shell in `<NoHydration>` and re-enter with `<Hydration>`
+ * around the app. Otherwise the app's hydration ids are allocated under the
+ * document component's owner tree and this walk can never claim them.
+ */
+export declare function hydrate(fn: () => JSX.Element, node: MountableElement, options?: {
+    renderId?: string;
+    owner?: unknown;
+}): () => void;
+export declare function getNextElement(template?: () => Element): Element;
+export declare function getNextMatch(start: Node, elementName: string): Element;
+export declare function getNextMarker(start: Node): [Node, Array<Node>];
+export declare function getFirstChild(node: any, expectedTag: any): any;
+export declare function getNextSibling(node: any, expectedTag: any): any;
+export declare function runHydrationEvents(): void;
+export declare function getHydrationKey(): string | undefined;
+export declare const RequestContext: unique symbol;

package/types/constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Flags
+ *
+ * - 1 - Stateful property - value derives from reactive state
+ * - 2 - Locked to property - value not specially treated
+ */
+declare const DOMWithState: Record<string, Record<string, 1 | 2>>;
+declare const ChildProperties: Set<string>;
+declare const $$SLOT: unique symbol;
+declare const $$HOST: unique symbol;
+declare const DelegatedEvents: Set<string>;
+declare const SVGElements: Set<string>;
+declare const MathMLElements: Set<string>;
+declare const Namespaces: Record<string, string>;
+declare const VoidElements: Set<string>;
+declare const RawTextElements: Set<string>;
+declare const DOMElements: Set<string>;
+export { DOMWithState, ChildProperties, DelegatedEvents, SVGElements, MathMLElements, VoidElements, RawTextElements, Namespaces, DOMElements, $$SLOT, $$HOST };

package/types/cookies.d.ts

@@ -1,93 +1,49 @@
-// Cookie wire format: the platform-gap primitives, and ALL of core's
-// cookie surface — core owns the exchange (the request's headers in, the
-// response stub's headers out) and the codec, nothing ambient. Blessed
-// patterns:
-//
-//   parseCookieHeader(event.request.headers.get("cookie"))
-//   event.response.headers.append("set-cookie", serializeCookie(name, value, options))
-//
-// Dependency-free and isomorphic (exported from both entries — real
-// implementation, never a stub); integrity/confidentiality layers
-// (sessions) belong to the caller, on top of these primitives.
-
-/**
- * Attributes for a `Set-Cookie` header, mirroring RFC 6265. `path`
- * defaults to `/`; nothing else is defaulted.
- */
 export interface CookieOptions {
-  /** Cookie `Path` attribute. Defaults to `/`. */
-  path?: string;
-  /** Cookie `Domain` attribute. Emitted only when provided. */
-  domain?: string;
-  /** Cookie `Max-Age` attribute, in seconds (truncated to an integer). */
-  maxAge?: number;
-  /** Cookie `Expires` attribute. */
-  expires?: Date;
-  /** Emit the `HttpOnly` attribute. */
-  httpOnly?: boolean;
-  /** Emit the `Secure` attribute. */
-  secure?: boolean;
-  /** Cookie `SameSite` attribute, any case. */
-  sameSite?: "lax" | "strict" | "none" | "Lax" | "Strict" | "None";
+    /** Cookie `Path` attribute. Defaults to `/`. */
+    path?: string;
+    /** Cookie `Domain` attribute. Emitted only when provided. */
+    domain?: string;
+    /** Cookie `Max-Age` attribute, in seconds (truncated to an integer). */
+    maxAge?: number;
+    /** Cookie `Expires` attribute. */
+    expires?: Date;
+    /** Emit the `HttpOnly` attribute. */
+    httpOnly?: boolean;
+    /** Emit the `Secure` attribute. */
+    secure?: boolean;
+    /** Cookie `SameSite` attribute, any case. */
+    sameSite?: "lax" | "strict" | "none" | "Lax" | "Strict" | "None";
 }
-
 /**
  * Parses a `Cookie` request header into a name → value map. Names and
  * values are `decodeURIComponent`-decoded (falling back to the raw text
- * when decoding throws); a quoted value keeps its content. `null`/empty
- * input parses to an empty map.
+ * when decoding throws — cookies set by other producers are not
+ * necessarily percent-encoded); a quoted value keeps its content, per the
+ * RFC 6265 grammar. `null`/empty input parses to an empty map.
  *
  * The read half of the platform gap — the blessed request-cookie read is
  * `parseCookieHeader(event.request.headers.get("cookie"))`.
  */
-export function parseCookieHeader(header: string | null | undefined): Record<string, string>;
-
+export declare function parseCookieHeader(header: string | null | undefined): Record<string, string>;
 /**
  * Serializes a cookie to a `Set-Cookie` header value. The name and value
  * are `encodeURIComponent`-encoded (the parser decodes symmetrically);
- * `path` defaults to `/` and every other attribute is emitted exactly
- * when the caller asked for it.
+ * `path` defaults to `/` — the only defaulted attribute — and every other
+ * attribute is emitted exactly when the caller asked for it: `domain`,
+ * `maxAge` (seconds, truncated to an integer), `expires` (a `Date`),
+ * `httpOnly`, `secure`, `sameSite` (`"lax" | "strict" | "none"`, any
+ * case).
  *
  * The write half of the platform gap — the blessed response-cookie write
  * is `event.response.headers.append("set-cookie", serializeCookie(name,
  * value, options))`, which every head materialization path carries to the
  * wire entry-by-entry.
  */
-export function serializeCookie(name: string, value: string, options?: CookieOptions): string;
-
-/**
- * Name of the cookie carrying the outcome of a server function call made
- * without the client runtime (`"flash"`). A no-JS form post has no way to
- * receive a value — the browser follows the redirect and renders the next
- * page — so the handler stashes the outcome here for the render after it
- * to pick up, which is how a form submitted without JavaScript still shows
- * its result.
- *
- * The name, detection and clearing are cookie utilities and isomorphic
- * (integrations read the cookie from code that also ships to the browser);
- * the codec that fills and decodes it is server-only and lives behind the
- * server-functions server entry.
- */
-export const FLASH_COOKIE: string;
-
-/**
- * Whether a Cookie header carries a flash cookie, readable or not. Cheap
- * enough to call on every render so the clear can be queued before the
- * response headers flush.
- */
-export function hasFlashCookie(cookieHeader: string | null): boolean;
-
-/**
- * The `Set-Cookie` value clearing the flash cookie. The outcome is
- * one-shot: append this as soon as the cookie is detected, whether or not
- * it decodes, so a stale outcome cannot resurface on a later request.
- */
-export function clearFlashCookie(): string;
-
-/**
- * The raw encoded flash payload out of a Cookie header, if present — the
- * codec's own accessor.
- *
- * @internal
- */
-export function matchFlashCookie(cookieHeader: string | null): string | undefined;
+export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;
+export declare const FLASH_COOKIE = "flash";
+/** Whether a Cookie header carries a flash cookie (readable or not). */
+export declare function hasFlashCookie(cookieHeader: string | null): boolean;
+/** The raw encoded flash payload out of a Cookie header, if present. */
+export declare function matchFlashCookie(cookieHeader: string | null): string | undefined;
+/** The Set-Cookie value clearing the flash cookie after it has been read. */
+export declare function clearFlashCookie(): string;