@shaferllc/keel 0.36.0 → 0.59.0

package/dist/core/testing.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A test client for Keel apps — inject requests without a live server and assert
+ * on the response, the way Fastify's `inject()` does. Wraps the app's Hono
+ * instance (which already does fetch-style request injection), adding verb
+ * helpers with JSON bodies and fluent response assertions.
+ *
+ *   const client = await testClient(app);
+ *   const res = await client.post("/users", { email: "a@b.com" });
+ *   res.assertStatus(201).assertJson({ id: 1, email: "a@b.com" });
+ *
+ * Edge-safe — no server, no port; the same injection Keel's own suite uses.
+ */
+import { Application } from "./application.js";
+import { HttpKernel } from "./http/kernel.js";
+interface Requestable {
+    request(input: string, init?: RequestInit): Promise<Response> | Response;
+}
+/** A response captured by the test client — body pre-read, so reads are sync. */
+export declare class TestResponse {
+    readonly raw: Response;
+    private readonly bodyText;
+    constructor(raw: Response, bodyText: string);
+    get status(): number;
+    header(name: string): string | null;
+    text(): string;
+    json<T = unknown>(): T;
+    assertStatus(expected: number): this;
+    /** Assert a 2xx status. */
+    assertOk(): this;
+    /** Assert the JSON body deep-equals `expected`. */
+    assertJson(expected: unknown): this;
+    assertText(expected: string): this;
+    assertHeader(name: string, value: string): this;
+    /** Assert a redirect (3xx) to `location`. */
+    assertRedirect(location?: string): this;
+}
+/** Injects requests into an app and returns `TestResponse`s. */
+export declare class TestClient {
+    private target;
+    constructor(target: Requestable);
+    request(path: string, init?: RequestInit): Promise<TestResponse>;
+    get(path: string, init?: RequestInit): Promise<TestResponse>;
+    delete(path: string, init?: RequestInit): Promise<TestResponse>;
+    post(path: string, body?: unknown, init?: RequestInit): Promise<TestResponse>;
+    put(path: string, body?: unknown, init?: RequestInit): Promise<TestResponse>;
+    patch(path: string, body?: unknown, init?: RequestInit): Promise<TestResponse>;
+}
+/**
+ * Build a `TestClient` from an `Application`, an `HttpKernel`, or anything with a
+ * `request()` (a built Hono instance). An `Application` is built through a fresh
+ * `HttpKernel`; pass a kernel yourself if you need global middleware registered.
+ */
+export declare function testClient(target: Application | HttpKernel | Requestable): TestClient;
+export {};

package/dist/core/testing.js

@@ -0,0 +1,141 @@
+/**
+ * A test client for Keel apps — inject requests without a live server and assert
+ * on the response, the way Fastify's `inject()` does. Wraps the app's Hono
+ * instance (which already does fetch-style request injection), adding verb
+ * helpers with JSON bodies and fluent response assertions.
+ *
+ *   const client = await testClient(app);
+ *   const res = await client.post("/users", { email: "a@b.com" });
+ *   res.assertStatus(201).assertJson({ id: 1, email: "a@b.com" });
+ *
+ * Edge-safe — no server, no port; the same injection Keel's own suite uses.
+ */
+import { Application } from "./application.js";
+import { HttpKernel } from "./http/kernel.js";
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length)
+        return false;
+    return ak.every((k) => deepEqual(a[k], b[k]));
+}
+/** A response captured by the test client — body pre-read, so reads are sync. */
+export class TestResponse {
+    raw;
+    bodyText;
+    constructor(raw, bodyText) {
+        this.raw = raw;
+        this.bodyText = bodyText;
+    }
+    get status() {
+        return this.raw.status;
+    }
+    header(name) {
+        return this.raw.headers.get(name);
+    }
+    text() {
+        return this.bodyText;
+    }
+    json() {
+        return JSON.parse(this.bodyText);
+    }
+    /* ------------------------------ assertions ---------------------------- */
+    assertStatus(expected) {
+        if (this.status !== expected) {
+            throw new Error(`Expected status ${expected}, got ${this.status}. Body: ${this.bodyText}`);
+        }
+        return this;
+    }
+    /** Assert a 2xx status. */
+    assertOk() {
+        if (this.status < 200 || this.status >= 300) {
+            throw new Error(`Expected a 2xx status, got ${this.status}. Body: ${this.bodyText}`);
+        }
+        return this;
+    }
+    /** Assert the JSON body deep-equals `expected`. */
+    assertJson(expected) {
+        const actual = this.json();
+        if (!deepEqual(actual, expected)) {
+            throw new Error(`JSON body mismatch.\n  expected: ${JSON.stringify(expected)}\n  actual:   ${JSON.stringify(actual)}`);
+        }
+        return this;
+    }
+    assertText(expected) {
+        if (this.bodyText !== expected) {
+            throw new Error(`Expected body "${expected}", got "${this.bodyText}"`);
+        }
+        return this;
+    }
+    assertHeader(name, value) {
+        const actual = this.header(name);
+        if (actual !== value) {
+            throw new Error(`Expected header ${name}: "${value}", got "${actual ?? "(absent)"}"`);
+        }
+        return this;
+    }
+    /** Assert a redirect (3xx) to `location`. */
+    assertRedirect(location) {
+        if (this.status < 300 || this.status >= 400) {
+            throw new Error(`Expected a redirect (3xx), got ${this.status}`);
+        }
+        if (location !== undefined)
+            this.assertHeader("location", location);
+        return this;
+    }
+}
+/** Injects requests into an app and returns `TestResponse`s. */
+export class TestClient {
+    target;
+    constructor(target) {
+        this.target = target;
+    }
+    async request(path, init = {}) {
+        const res = await this.target.request(path, init);
+        const text = await res.text();
+        return new TestResponse(res, text);
+    }
+    get(path, init) {
+        return this.request(path, { ...init, method: "GET" });
+    }
+    delete(path, init) {
+        return this.request(path, { ...init, method: "DELETE" });
+    }
+    post(path, body, init) {
+        return this.request(path, withJson("POST", body, init));
+    }
+    put(path, body, init) {
+        return this.request(path, withJson("PUT", body, init));
+    }
+    patch(path, body, init) {
+        return this.request(path, withJson("PATCH", body, init));
+    }
+}
+function withJson(method, body, init = {}) {
+    if (body === undefined)
+        return { ...init, method };
+    return {
+        ...init,
+        method,
+        headers: { "content-type": "application/json", ...init.headers },
+        body: JSON.stringify(body),
+    };
+}
+/**
+ * Build a `TestClient` from an `Application`, an `HttpKernel`, or anything with a
+ * `request()` (a built Hono instance). An `Application` is built through a fresh
+ * `HttpKernel`; pass a kernel yourself if you need global middleware registered.
+ */
+export function testClient(target) {
+    if (target instanceof Application)
+        return new TestClient(new HttpKernel(target).build());
+    if (target instanceof HttpKernel)
+        return new TestClient(target.build());
+    return new TestClient(target);
+}

package/dist/core/transformer.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Transformers — a presentation layer between your models and your JSON. A model
+ * knows the database; a transformer knows the API. Subclass `Transformer`, define
+ * one `transform()` that maps a value to the exact shape you want to expose, and
+ * get `item` / `collection` / `document` for free.
+ *
+ *   class UserTransformer extends Transformer<User> {
+ *     transform(user: User) {
+ *       return {
+ *         id: user.id,
+ *         name: user.name,
+ *         email: this.when(user.id === viewerId, user.email),   // omit for others
+ *         posts: this.whenLoaded(user, "posts", new PostTransformer()),
+ *       };
+ *     }
+ *   }
+ *
+ *   json(new UserTransformer().item(user));                 // one → {…}
+ *   json(new UserTransformer().collection(users));          // many → [{…}]
+ *   json(new UserTransformer().document(users, {            // wrapped + meta
+ *     meta: { total: users.length },
+ *   }));                                                    // → { data: [{…}], total }
+ *
+ * The seam is deliberately thin: a transformer is just a function with helpers.
+ * `when` drops a key entirely when a condition is false (no `null` leaking into
+ * the payload), and `whenLoaded` includes a relation only if it was eager-loaded
+ * — so a transformer never triggers a surprise query. It leans on nothing but the
+ * value you hand it, so it runs on Node and the edge alike.
+ */
+/** The shape a transformer produces — a plain, JSON-ready object. */
+export type Attributes = Record<string, unknown>;
+/** Options for `document()` — how to wrap the payload and what meta to attach. */
+export interface DocumentOptions {
+    /** Wrap the payload under this key. `null` disables wrapping. Defaults to `wrapKey`. */
+    key?: string | null;
+    /** Top-level fields merged alongside the wrapper — pagination, counts, links. */
+    meta?: Attributes;
+}
+/** A transformer for a related value: another transformer, or a plain mapping fn. */
+type Related = Transformer<never> | ((value: never) => unknown);
+export declare abstract class Transformer<T = unknown> {
+    /** The key `document()` wraps under by default. Set to `null` to wrap nothing. */
+    wrapKey: string | null;
+    /** Map one value to its API shape. The only method a subclass must implement. */
+    abstract transform(item: T): Attributes;
+    /** Transform a single value (a nullish value passes straight through as `null`). */
+    item(value: T | null | undefined): Attributes | null;
+    /** Transform an array of values, each through `transform`. */
+    collection(values: T[]): Attributes[];
+    /**
+     * Build a response document: the transformed payload wrapped under a key, with
+     * optional top-level `meta`. Pass a single value or an array — arrays become a
+     * list under the key, everything else a single object.
+     *
+     *   new UserTransformer().document(users, { meta: { total: 3 } });
+     *   // → { data: [{…}, {…}, {…}], total: 3 }
+     */
+    document(value: T | T[] | null | undefined, options?: DocumentOptions): Attributes;
+    /**
+     * Include `value` only when `condition` is truthy; otherwise omit the key (or
+     * use `fallback` if you pass one). `value` may be a thunk, deferred until the
+     * condition holds — handy when computing it is expensive.
+     *
+     *   { email: this.when(isSelf, user.email) }          // key vanishes for others
+     *   { token: this.when(fresh, () => mint(), null) }   // explicit fallback
+     */
+    protected when<V>(condition: unknown, value: V | (() => V), fallback?: V): V;
+    /**
+     * Spread several keys in at once, but only when `condition` holds — the merge
+     * counterpart to `when`. Returns `{}` when false, so `...mergeWhen(…)` adds
+     * nothing.
+     *
+     *   return { id: u.id, ...this.mergeWhen(isAdmin, { role: u.role, flags: u.flags }) };
+     */
+    protected mergeWhen(condition: unknown, values: Attributes | (() => Attributes)): Attributes;
+    /**
+     * Include a relation only if it was already loaded — never fires a query. Reads
+     * an eager-loaded relation off a Keel model (via `getRelation`) or a plain
+     * property, and, if present, runs it through `map` (a transformer or a function).
+     * Omits the key when the relation isn't loaded.
+     *
+     *   posts: this.whenLoaded(user, "posts", new PostTransformer()),
+     *   roles: this.whenLoaded(user, "roles", (rs) => rs.map((r) => r.name)),
+     */
+    protected whenLoaded<V>(model: unknown, name: string, map?: Related): V;
+    /** Recursively drop `OMIT` keys/elements so the payload is clean, plain JSON. */
+    private prune;
+}
+export {};

package/dist/core/transformer.js

@@ -0,0 +1,152 @@
+/**
+ * Transformers — a presentation layer between your models and your JSON. A model
+ * knows the database; a transformer knows the API. Subclass `Transformer`, define
+ * one `transform()` that maps a value to the exact shape you want to expose, and
+ * get `item` / `collection` / `document` for free.
+ *
+ *   class UserTransformer extends Transformer<User> {
+ *     transform(user: User) {
+ *       return {
+ *         id: user.id,
+ *         name: user.name,
+ *         email: this.when(user.id === viewerId, user.email),   // omit for others
+ *         posts: this.whenLoaded(user, "posts", new PostTransformer()),
+ *       };
+ *     }
+ *   }
+ *
+ *   json(new UserTransformer().item(user));                 // one → {…}
+ *   json(new UserTransformer().collection(users));          // many → [{…}]
+ *   json(new UserTransformer().document(users, {            // wrapped + meta
+ *     meta: { total: users.length },
+ *   }));                                                    // → { data: [{…}], total }
+ *
+ * The seam is deliberately thin: a transformer is just a function with helpers.
+ * `when` drops a key entirely when a condition is false (no `null` leaking into
+ * the payload), and `whenLoaded` includes a relation only if it was eager-loaded
+ * — so a transformer never triggers a surprise query. It leans on nothing but the
+ * value you hand it, so it runs on Node and the edge alike.
+ */
+/**
+ * The sentinel a helper returns to mean "leave this key out". `item`/`collection`
+ * prune it before the payload is ever seen, so `{ email: this.when(false, …) }`
+ * yields `{}` rather than `{ email: undefined }`.
+ */
+const OMIT = Symbol("keel.transformer.omit");
+export class Transformer {
+    /** The key `document()` wraps under by default. Set to `null` to wrap nothing. */
+    wrapKey = "data";
+    /** Transform a single value (a nullish value passes straight through as `null`). */
+    item(value) {
+        return value == null ? null : this.prune(this.transform(value));
+    }
+    /** Transform an array of values, each through `transform`. */
+    collection(values) {
+        return values.map((value) => this.prune(this.transform(value)));
+    }
+    /**
+     * Build a response document: the transformed payload wrapped under a key, with
+     * optional top-level `meta`. Pass a single value or an array — arrays become a
+     * list under the key, everything else a single object.
+     *
+     *   new UserTransformer().document(users, { meta: { total: 3 } });
+     *   // → { data: [{…}, {…}, {…}], total: 3 }
+     */
+    document(value, options = {}) {
+        const key = options.key !== undefined ? options.key : this.wrapKey;
+        const meta = options.meta ?? {};
+        const payload = Array.isArray(value) ? this.collection(value) : this.item(value);
+        if (key)
+            return { [key]: payload, ...meta };
+        // No wrapper: merge a single object's fields to the top level. An array can't
+        // share the top level with meta, so it still gets a `data` home.
+        if (payload && !Array.isArray(payload))
+            return { ...payload, ...meta };
+        return { data: payload, ...meta };
+    }
+    /* ------------------------------- helpers -------------------------------- */
+    /**
+     * Include `value` only when `condition` is truthy; otherwise omit the key (or
+     * use `fallback` if you pass one). `value` may be a thunk, deferred until the
+     * condition holds — handy when computing it is expensive.
+     *
+     *   { email: this.when(isSelf, user.email) }          // key vanishes for others
+     *   { token: this.when(fresh, () => mint(), null) }   // explicit fallback
+     */
+    when(condition, value, fallback) {
+        if (condition)
+            return typeof value === "function" ? value() : value;
+        return (arguments.length >= 3 ? fallback : OMIT);
+    }
+    /**
+     * Spread several keys in at once, but only when `condition` holds — the merge
+     * counterpart to `when`. Returns `{}` when false, so `...mergeWhen(…)` adds
+     * nothing.
+     *
+     *   return { id: u.id, ...this.mergeWhen(isAdmin, { role: u.role, flags: u.flags }) };
+     */
+    mergeWhen(condition, values) {
+        if (!condition)
+            return {};
+        return typeof values === "function" ? values() : values;
+    }
+    /**
+     * Include a relation only if it was already loaded — never fires a query. Reads
+     * an eager-loaded relation off a Keel model (via `getRelation`) or a plain
+     * property, and, if present, runs it through `map` (a transformer or a function).
+     * Omits the key when the relation isn't loaded.
+     *
+     *   posts: this.whenLoaded(user, "posts", new PostTransformer()),
+     *   roles: this.whenLoaded(user, "roles", (rs) => rs.map((r) => r.name)),
+     */
+    whenLoaded(model, name, map) {
+        const related = readRelation(model, name);
+        if (related === undefined)
+            return OMIT;
+        if (map instanceof Transformer) {
+            const via = map;
+            return (Array.isArray(related) ? via.collection(related) : via.item(related));
+        }
+        if (typeof map === "function")
+            return map(related);
+        return related;
+    }
+    /* ------------------------------ internals ------------------------------- */
+    /** Recursively drop `OMIT` keys/elements so the payload is clean, plain JSON. */
+    prune(value) {
+        if (Array.isArray(value)) {
+            return value.filter((entry) => entry !== OMIT).map((entry) => this.prune(entry));
+        }
+        if (isPlainObject(value)) {
+            const out = {};
+            for (const [key, entry] of Object.entries(value)) {
+                if (entry === OMIT)
+                    continue;
+                out[key] = this.prune(entry);
+            }
+            return out;
+        }
+        return value;
+    }
+}
+/** Read an eager-loaded relation without ever querying: `getRelation`, then a plain prop. */
+function readRelation(model, name) {
+    if (model && typeof model === "object") {
+        const record = model;
+        if (typeof record.getRelation === "function") {
+            return record.getRelation(name);
+        }
+        const value = record[name];
+        // A relation *method* isn't a loaded value — only a stored result counts.
+        if (typeof value !== "function")
+            return value;
+    }
+    return undefined;
+}
+/** True for object literals (and `Object.create(null)`) — not class instances, arrays, or Dates. */
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}

package/dist/core/validation.d.ts

@@ -7,6 +7,7 @@
  * (Zod, and anything that mirrors its shape), so the framework never bundles a
  * validation library — bring your own.
  */
+import type { MiddlewareHandler } from "hono";
 /** The minimal shape Keel needs from a schema — Zod satisfies this. */
 export interface Schema<T> {
     safeParse(data: unknown): {
@@ -30,3 +31,22 @@ export interface Schema<T> {
  *   const q = validate(SearchQuery, request.query());  // validates given data
  */
 export declare function validate<T>(schema: Schema<T>, data?: unknown): Promise<T>;
+/** Schemas to validate parts of the request against, before the handler runs. */
+export interface RequestSchemas {
+    body?: Schema<unknown>;
+    query?: Schema<unknown>;
+    params?: Schema<unknown>;
+}
+/**
+ * Middleware that validates the request against `schemas` *before* the handler,
+ * rejecting with a 422 `ValidationException` if any part fails (errors from all
+ * parts are aggregated, keyed `body.field` / `query.field` / `params.field`).
+ * On success the parsed, typed values are stashed for `validated()`.
+ *
+ *   router.post("/users", [Users, "store"]).middleware([validateRequest({ body: NewUser })]);
+ *   // in the handler:
+ *   const user = validated<NewUser>("body");
+ */
+export declare function validateRequest(schemas: RequestSchemas): MiddlewareHandler;
+/** The validated, typed value for a request part (set by `validateRequest`). */
+export declare function validated<T = unknown>(part?: keyof RequestSchemas): T;

package/dist/core/validation.js

@@ -8,7 +8,7 @@
  * validation library — bring your own.
  */
 import { ValidationException } from "./exceptions.js";
-import { body } from "./request.js";
+import { body, ctx } from "./request.js";
 /**
  * Validate `data` (or the request JSON body, if omitted) against a schema.
  * Returns the parsed, typed value; throws `ValidationException` on failure.
@@ -31,3 +31,54 @@ export async function validate(schema, data) {
     }
     throw new ValidationException(errors);
 }
+const validatedStore = new WeakMap();
+function fieldKey(path) {
+    return (path.map((p) => (typeof p === "symbol" ? (p.description ?? "") : String(p))).join(".") || "_");
+}
+/**
+ * Middleware that validates the request against `schemas` *before* the handler,
+ * rejecting with a 422 `ValidationException` if any part fails (errors from all
+ * parts are aggregated, keyed `body.field` / `query.field` / `params.field`).
+ * On success the parsed, typed values are stashed for `validated()`.
+ *
+ *   router.post("/users", [Users, "store"]).middleware([validateRequest({ body: NewUser })]);
+ *   // in the handler:
+ *   const user = validated<NewUser>("body");
+ */
+export function validateRequest(schemas) {
+    return async (c, next) => {
+        const parsed = {};
+        const errors = {};
+        const parts = [
+            ["body", () => body()],
+            ["query", () => c.req.query()],
+            ["params", () => c.req.param()],
+        ];
+        for (const [name, read] of parts) {
+            const schema = schemas[name];
+            if (!schema)
+                continue;
+            const result = schema.safeParse(await read());
+            if (result.success) {
+                parsed[name] = result.data;
+            }
+            else {
+                for (const issue of result.error.issues) {
+                    (errors[`${name}.${fieldKey(issue.path)}`] ??= []).push(issue.message);
+                }
+            }
+        }
+        if (Object.keys(errors).length)
+            throw new ValidationException(errors);
+        validatedStore.set(c, parsed);
+        await next();
+    };
+}
+/** The validated, typed value for a request part (set by `validateRequest`). */
+export function validated(part = "body") {
+    const store = validatedStore.get(ctx());
+    if (!store || !(part in store)) {
+        throw new Error(`No validated "${part}". Add validateRequest({ ${part}: schema }) to the route.`);
+    }
+    return store[part];
+}

package/dist/core/vite.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Vite integration. Wire a modern frontend build — bundling, hashed filenames,
+ * hot module reload — to Keel's server-rendered HTML, the way modern full-stack
+ * frameworks do. `Vite` is the *server* half: it emits the `<script>`/`<link>`
+ * tags for your entrypoints and resolves individual asset URLs, switching
+ * automatically between two modes:
+ *
+ *   • Dev — a `public/hot` file (written by the `keelVite()` plugin when the
+ *     Vite dev server starts) points at `http://localhost:5173`. Tags load
+ *     straight from that server, with HMR.
+ *   • Prod — no hot file, so it reads `public/assets/.vite/manifest.json` and
+ *     emits the hashed, split, preloaded production tags.
+ *
+ *   // in a service provider
+ *   const vite = await new Vite({ entrypoints: ["resources/js/app.ts"] }).loadFromDisk();
+ *   singleton(Vite, () => vite);
+ *
+ *   // in a JSX layout <head>
+ *   {viteReactRefresh()}
+ *   {viteTags("resources/js/app.ts")}
+ *
+ * Tag generation is pure string work over an in-memory manifest, so it's
+ * edge-safe: on Workers, skip `loadFromDisk` and hand the bundled manifest in
+ * with `useManifest(...)`. Only reading from disk touches `node:fs`, and that's
+ * imported dynamically (like the static server), so the core still loads on the
+ * edge.
+ */
+import type { HtmlEscapedString } from "hono/utils/html";
+/** One chunk in Vite's `manifest.json`. */
+export interface ManifestChunk {
+    file: string;
+    name?: string;
+    src?: string;
+    isEntry?: boolean;
+    isDynamicEntry?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+    css?: string[];
+    assets?: string[];
+}
+/** A parsed Vite build manifest: source path → chunk. */
+export type Manifest = Record<string, ManifestChunk>;
+/** An HTML attribute value: a string, `true` (bare attribute), or absent. */
+export type AttrValue = string | boolean | null | undefined;
+/** A bag of HTML attributes, or a function that computes them per asset. */
+export type Attributes = Record<string, AttrValue> | ((asset: {
+    src: string;
+    url: string;
+}) => Record<string, AttrValue> | undefined);
+export interface ViteOptions {
+    /** Entrypoints to tag when `generateEntryPointsTags()` is called with none. */
+    entrypoints?: string | string[];
+    /** The dev-server marker file. Default: `public/hot`. */
+    hotFile?: string;
+    /** Where the build lands (holds `.vite/manifest.json`). Default: `public/assets`. */
+    buildDirectory?: string;
+    /** Override the manifest path. Default: `<buildDirectory>/.vite/manifest.json`. */
+    manifestFile?: string;
+    /** Public URL prefix for built assets (a CDN base works too). Default: `/assets`. */
+    assetsUrl?: string;
+    /** Extra attributes for generated `<script>` tags. */
+    scriptAttributes?: Attributes;
+    /** Extra attributes for generated `<link rel="stylesheet">` tags. */
+    styleAttributes?: Attributes;
+}
+export declare class Vite {
+    private entrypoints;
+    private hotFile;
+    private manifestFile;
+    private assetsUrl;
+    private scriptAttributes;
+    private styleAttributes;
+    private hotUrl;
+    private parsed;
+    private fs;
+    constructor(options?: ViteOptions);
+    /**
+     * Read the hot file (dev) or the build manifest (prod) from disk. Call once at
+     * boot from a service provider. Node only — uses `node:fs`.
+     */
+    loadFromDisk(): Promise<this>;
+    /** Inject a manifest directly — for the edge, where there's no filesystem. */
+    useManifest(manifest: Manifest): this;
+    /** Force the dev-server URL (or `null` for prod). Bypasses the hot file. */
+    useHotUrl(url: string | null): this;
+    /** Re-read the hot file if we're on Node and no manifest has claimed prod mode. */
+    private refreshHot;
+    /** The dev-server URL when running Vite, else `null` (production). */
+    hot(): string | null;
+    /** The parsed production manifest. Throws if it hasn't been loaded. */
+    manifest(): Manifest;
+    /**
+     * The `<script>`/`<link>` tags for one or more entrypoints — dev-server URLs
+     * with HMR while developing, hashed + preloaded tags in production. Falls back
+     * to the entrypoints passed to the constructor.
+     */
+    generateEntryPointsTags(entrypoints?: string | string[]): HtmlEscapedString;
+    /** The public URL for a single asset (an image, a font) — dev or hashed prod. */
+    assetPath(asset: string): string;
+    /**
+     * The React Fast Refresh preamble — required before your entry script when
+     * using `@vitejs/plugin-react`. Empty in production.
+     */
+    reactHMR(): HtmlEscapedString;
+    private devTags;
+    private productionTags;
+    /** In dev, a style entrypoint is a `<link>`; everything else a module script. */
+    private tagFor;
+    private scriptTag;
+    private styleTag;
+}
+/** The entrypoint tags for the current app's Vite instance. Use in a JSX `<head>`. */
+export declare function viteTags(entrypoints?: string | string[]): HtmlEscapedString;
+/** The URL for a single asset through the current app's Vite instance. */
+export declare function viteAsset(asset: string): string;
+/** The React Fast Refresh preamble (dev only) for the current app's Vite instance. */
+export declare function viteReactRefresh(): HtmlEscapedString;