tachyon-dom 0.1.0

package/dist/server/form-action.d.ts

@@ -0,0 +1,52 @@
+import { attr, type HtmlFragment } from "./html.js";
+export type FormValue = string | string[];
+export type FormState<Fields extends string = string> = {
+    values: Partial<Record<Fields, FormValue>>;
+    fieldErrors: Partial<Record<Fields, string>>;
+    formError?: string;
+    notice?: string;
+};
+export type FormActionResult<Input, ErrorState> = {
+    ok: true;
+    value: Input;
+} | {
+    ok: false;
+    error: ErrorState;
+};
+export type FormActionContext = {
+    request: Request;
+    formData: FormData;
+};
+export type FormActionOptions<Input, ErrorState> = {
+    parse: (formData: FormData, context: FormActionContext) => FormActionResult<Input, ErrorState> | Promise<FormActionResult<Input, ErrorState>>;
+    onSuccess: (context: FormActionContext & {
+        input: Input;
+    }) => Response | Promise<Response>;
+    onError: (context: FormActionContext & {
+        error: ErrorState;
+    }) => Response | Promise<Response>;
+};
+export type PreserveFormValuesOptions = {
+    sensitiveNames?: readonly string[];
+    include?: readonly string[];
+    exclude?: readonly string[];
+};
+export type RedirectResponseOptions = ResponseInit & {
+    allowExternal?: boolean;
+    allowedOrigins?: readonly string[];
+};
+export type FormFieldOptions = {
+    id?: string;
+    name?: string;
+    errorId?: string;
+};
+export declare const formState: <Fields extends string = string>(state?: Partial<FormState<Fields>>) => FormState<Fields>;
+export declare const preserveFormValues: (formData: FormData, options?: PreserveFormValuesOptions) => Record<string, FormValue>;
+export declare const redirectResponse: (location: string, init?: RedirectResponseOptions) => Response;
+export declare const formAction: <Input, ErrorState>({ parse, onSuccess, onError, }: FormActionOptions<Input, ErrorState>) => ((request: Request) => Promise<Response>);
+export declare const formField: <Fields extends string>(state: FormState<Fields>, fieldName: Fields, options?: FormFieldOptions) => {
+    inputAttrs: () => ReturnType<typeof attr>[];
+    error: () => HtmlFragment;
+    errorId: string;
+    value: FormValue | undefined;
+};

package/dist/server/form-action.js

@@ -0,0 +1,102 @@
+import { attr, html } from "./html.js";
+const defaultSensitiveNames = ["password", "currentPassword", "newPassword", "confirmPassword", "passwordConfirmation"];
+const stringValue = (value) => typeof File !== "undefined" && value instanceof File ? value.name : String(value);
+const fieldIdFor = (name) => name.replaceAll(/[^A-Za-z0-9_-]+/g, "-").replaceAll(/^-|-$/g, "") || "field";
+const appendValue = (values, name, value) => {
+    const current = values[name];
+    if (current === undefined) {
+        values[name] = value;
+    }
+    else if (Array.isArray(current)) {
+        current.push(value);
+    }
+    else {
+        values[name] = [current, value];
+    }
+};
+export const formState = (state = {}) => ({
+    values: state.values ?? {},
+    fieldErrors: state.fieldErrors ?? {},
+    ...(state.formError !== undefined ? { formError: state.formError } : {}),
+    ...(state.notice !== undefined ? { notice: state.notice } : {}),
+});
+export const preserveFormValues = (formData, options = {}) => {
+    const sensitiveNames = new Set(options.sensitiveNames ?? defaultSensitiveNames);
+    const include = options.include ? new Set(options.include) : undefined;
+    const exclude = new Set(options.exclude ?? []);
+    const values = {};
+    for (const [name, value] of formData) {
+        if (sensitiveNames.has(name) || exclude.has(name) || (include && !include.has(name))) {
+            continue;
+        }
+        appendValue(values, name, stringValue(value));
+    }
+    return values;
+};
+const isSafePathRedirect = (location) => {
+    const controlCharacterPattern = /[\u0000-\u001F\u007F]/;
+    if (!location.startsWith("/") || location.startsWith("//") || controlCharacterPattern.test(location)) {
+        return false;
+    }
+    try {
+        const decoded = decodeURIComponent(location);
+        return !decoded.startsWith("//") && !decoded.includes("\\") && !controlCharacterPattern.test(decoded);
+    }
+    catch {
+        return false;
+    }
+};
+const isApprovedExternalRedirect = (location, allowedOrigins) => {
+    if (!allowedOrigins || allowedOrigins.length === 0) {
+        return false;
+    }
+    try {
+        const url = new URL(location);
+        return (url.protocol === "https:" || url.protocol === "http:") && allowedOrigins.includes(url.origin);
+    }
+    catch {
+        return false;
+    }
+};
+export const redirectResponse = (location, init = {}) => {
+    if (!isSafePathRedirect(location) &&
+        !(init.allowExternal && isApprovedExternalRedirect(location, init.allowedOrigins))) {
+        throw new Error(`Unsafe redirect target: ${location}`);
+    }
+    const headers = new Headers(init.headers);
+    headers.set("location", location);
+    return new Response(null, { ...init, status: init.status ?? 303, headers });
+};
+export const formAction = ({ parse, onSuccess, onError, }) => {
+    return async (request) => {
+        const formData = await request.formData();
+        const context = { request, formData };
+        const result = await parse(formData, context);
+        if (result.ok) {
+            return onSuccess({ ...context, input: result.value });
+        }
+        return onError({ ...context, error: result.error });
+    };
+};
+export const formField = (state, fieldName, options = {}) => {
+    const name = options.name ?? fieldName;
+    const id = options.id ?? fieldIdFor(name);
+    const error = state.fieldErrors[fieldName];
+    const errorId = options.errorId ?? `${id}-error`;
+    const value = state.values[fieldName];
+    return {
+        errorId,
+        value,
+        inputAttrs: () => {
+            const firstValue = Array.isArray(value) ? (value[0] ?? "") : (value ?? "");
+            return [
+                attr("name", name),
+                attr("id", id),
+                attr("value", firstValue),
+                attr("aria-invalid", error ? "true" : undefined),
+                attr("aria-describedby", error ? errorId : undefined),
+            ];
+        },
+        error: () => (error ? html `<p${attr("id", errorId)} role="alert">${error}</p>` : html ``),
+    };
+};

package/dist/server/html.d.ts

@@ -0,0 +1,19 @@
+declare const htmlFragmentBrand: unique symbol;
+declare const htmlAttributeBrand: unique symbol;
+export type HtmlFragment = {
+    readonly [htmlFragmentBrand]: true;
+    toString(): string;
+};
+export type HtmlAttribute = {
+    readonly [htmlAttributeBrand]: true;
+    toString(): string;
+};
+type HtmlValue = HtmlFragment | HtmlAttribute | readonly HtmlValue[] | string | number | boolean | null | undefined;
+type ClassValue = string | number | false | null | undefined | readonly ClassValue[];
+export declare const rawHtml: (value: string) => HtmlFragment;
+export declare const join: (values: readonly HtmlValue[], separator?: string) => HtmlFragment;
+export declare const attr: (name: string, value: unknown) => HtmlAttribute;
+export declare const booleanAttr: (name: string, enabled: boolean | null | undefined) => HtmlAttribute;
+export declare const classList: (...values: readonly ClassValue[]) => string;
+export declare const html: (strings: TemplateStringsArray, ...values: readonly HtmlValue[]) => HtmlFragment;
+export {};

package/dist/server/html.js

@@ -0,0 +1,101 @@
+import { escapeHtml as escapeText } from "../html-escape.js";
+const htmlFragmentBrand = Symbol("tachyon.htmlFragment");
+const htmlAttributeBrand = Symbol("tachyon.htmlAttribute");
+const attributeNamePattern = /^[A-Za-z_:][A-Za-z0-9_.:-]*$/;
+const attributeContextPattern = /(?:^|[\s<])(?:[A-Za-z_:][A-Za-z0-9_.:-]*)(?:\s*)=(?:\s*)$/;
+const fragment = (value) => ({
+    [htmlFragmentBrand]: true,
+    toString: () => value,
+});
+const attributeFragment = (value) => ({
+    [htmlAttributeBrand]: true,
+    toString: () => value,
+});
+const isHtmlFragment = (value) => Boolean(value && typeof value === "object" && value[htmlFragmentBrand] === true);
+const isHtmlAttribute = (value) => Boolean(value && typeof value === "object" && value[htmlAttributeBrand] === true);
+const attributeEscapeMap = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+    "`": "&#96;",
+};
+const attributeEscapePattern = /[&<>"'`]/;
+const attributeEscapeGlobalPattern = /[&<>"'`]/g;
+const escapeAttribute = (value) => {
+    const text = String(value ?? "");
+    return attributeEscapePattern.test(text)
+        ? text.replace(attributeEscapeGlobalPattern, (char) => attributeEscapeMap[char] ?? char)
+        : text;
+};
+const assertAttributeName = (name) => {
+    if (!attributeNamePattern.test(name)) {
+        throw new Error(`Invalid attribute name: ${name}`);
+    }
+};
+const renderValue = (value, context) => {
+    if (value == null || value === false) {
+        return "";
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => renderValue(item, context)).join("");
+    }
+    if (isHtmlAttribute(value)) {
+        return value.toString();
+    }
+    if (isHtmlFragment(value)) {
+        return value.toString();
+    }
+    if (context === "attribute") {
+        return `"${escapeAttribute(value)}"`;
+    }
+    return escapeText(value);
+};
+export const rawHtml = (value) => fragment(value);
+export const join = (values, separator = "") => fragment(values.map((value) => renderValue(value, "text")).join(separator));
+export const attr = (name, value) => {
+    assertAttributeName(name);
+    if (value == null || value === false) {
+        return attributeFragment("");
+    }
+    if (value === true) {
+        return attributeFragment(` ${name}`);
+    }
+    return attributeFragment(` ${name}="${escapeAttribute(value)}"`);
+};
+export const booleanAttr = (name, enabled) => {
+    assertAttributeName(name);
+    return enabled ? attributeFragment(` ${name}`) : attributeFragment("");
+};
+export const classList = (...values) => {
+    const classes = [];
+    const collect = (value) => {
+        if (!value) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                collect(item);
+            }
+            return;
+        }
+        classes.push(String(value));
+    };
+    for (const value of values) {
+        collect(value);
+    }
+    return classes.join(" ");
+};
+export const html = (strings, ...values) => {
+    let output = "";
+    for (let index = 0; index < strings.length; index += 1) {
+        const literal = strings[index] ?? "";
+        output += literal;
+        if (index < values.length) {
+            const context = attributeContextPattern.test(literal) ? "attribute" : "text";
+            output += renderValue(values[index], context);
+        }
+    }
+    return fragment(output);
+};

package/dist/server/stream.d.ts

@@ -0,0 +1,4 @@
+export type HtmlChunk = string | Uint8Array;
+export type HtmlChunkSource = Iterable<HtmlChunk | Promise<HtmlChunk>> | AsyncIterable<HtmlChunk>;
+export declare const renderToReadableStream: (chunks: HtmlChunkSource) => ReadableStream<Uint8Array>;
+export declare const renderToResponse: (chunks: HtmlChunkSource, init?: ResponseInit) => Response;

package/dist/server/stream.js

@@ -0,0 +1,72 @@
+const encoder = new TextEncoder();
+const coalescedChunkTargetBytes = 8192;
+const isAsyncIterable = (value) => Symbol.asyncIterator in value;
+const toBytes = (chunk) => (typeof chunk === "string" ? encoder.encode(chunk) : chunk);
+async function* toAsyncChunks(source) {
+    if (isAsyncIterable(source)) {
+        yield* source;
+        return;
+    }
+    let textBuffer = "";
+    let textBufferBytes = 0;
+    const flush = function* () {
+        if (textBufferBytes > 0) {
+            yield textBuffer;
+            textBuffer = "";
+            textBufferBytes = 0;
+        }
+    };
+    for (const chunk of source) {
+        const resolved = await chunk;
+        if (typeof resolved !== "string") {
+            yield* flush();
+            yield resolved;
+            continue;
+        }
+        if (resolved.length === 0) {
+            continue;
+        }
+        textBuffer += resolved;
+        textBufferBytes += toBytes(resolved).byteLength;
+        if (textBufferBytes >= coalescedChunkTargetBytes) {
+            yield* flush();
+        }
+    }
+    yield* flush();
+}
+export const renderToReadableStream = (chunks) => {
+    const iterator = toAsyncChunks(chunks)[Symbol.asyncIterator]();
+    let cancelled = false;
+    return new ReadableStream({
+        async pull(controller) {
+            if (cancelled) {
+                return;
+            }
+            try {
+                const result = await iterator.next();
+                if (result.done) {
+                    controller.close();
+                    return;
+                }
+                const bytes = toBytes(result.value);
+                if (bytes.byteLength > 0) {
+                    controller.enqueue(bytes);
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel() {
+            cancelled = true;
+            await iterator.return?.();
+        },
+    });
+};
+export const renderToResponse = (chunks, init = {}) => {
+    const headers = new Headers(init.headers);
+    if (!headers.has("content-type")) {
+        headers.set("content-type", "text/html; charset=utf-8");
+    }
+    return new Response(renderToReadableStream(chunks), { ...init, headers });
+};

package/dist/source-map.d.ts

@@ -0,0 +1,17 @@
+export type SourceMap = {
+    version: 3;
+    file?: string;
+    sources: string[];
+    sourcesContent: string[];
+    names: string[];
+    mappings: string;
+};
+export type SourceMapBuildContext = {
+    sourcemap?: boolean | undefined;
+    productionSourceMap?: boolean | undefined;
+    command?: string | undefined;
+    mode?: string | undefined;
+};
+export declare const createSourceMap: (source: string, sourceFile?: string, outputFile?: string) => SourceMap;
+export declare const shouldEmitSourceMap: (context?: SourceMapBuildContext) => boolean;
+export declare const appendInlineSourceMap: (code: string, map: SourceMap) => string;

package/dist/source-map.js

@@ -0,0 +1,18 @@
+export const createSourceMap = (source, sourceFile = "template.tachyon.html", outputFile) => ({
+    version: 3,
+    ...(outputFile ? { file: outputFile } : {}),
+    sources: [sourceFile],
+    sourcesContent: [source],
+    names: [],
+    mappings: "",
+});
+export const shouldEmitSourceMap = (context = {}) => {
+    if (context.productionSourceMap === false && context.command === "build" && context.mode === "production") {
+        return false;
+    }
+    return context.sourcemap !== false;
+};
+export const appendInlineSourceMap = (code, map) => {
+    const encoded = Buffer.from(JSON.stringify(map), "utf8").toString("base64");
+    return `${code}\n//# sourceMappingURL=data:application/json;base64,${encoded}\n`;
+};

package/dist/tachyon-html.d.ts

@@ -0,0 +1,110 @@
+declare module "*.td" {
+  const defaultScope: Record<string, unknown> | ((scope: Record<string, unknown>) => Record<string, unknown>);
+  export default defaultScope;
+  export const scope: Record<string, unknown> | ((scope: Record<string, unknown>) => Record<string, unknown>);
+  export const templateHtml: string;
+  export const hydrationBoundaries: unknown[];
+  export const componentBoundaries: unknown[];
+  export const bind: (root: Element, scope: Record<string, unknown>) => void | (() => void);
+}
+
+declare module "*.td?raw" {
+  const source: string;
+  export default source;
+}
+
+declare module "*.td?client" {
+  export const templateHtml: string;
+  export const hydrationBoundaries: unknown[];
+  export const componentBoundaries: unknown[];
+  export const bind: (root: Element, scope: Record<string, unknown>) => void | (() => void);
+}
+
+declare module "*.td?server" {
+  export const hydrationBoundaries: unknown[];
+  export const renderHydrationState: (id: string, state: unknown) => string;
+  export const render: (scope: Record<string, unknown>) => string;
+}
+
+declare module "*.td?stream" {
+  export const stream: (scope: Record<string, unknown>) => AsyncIterable<string>;
+}
+
+declare module "*.td?entry" {
+  const module: Record<string, unknown>;
+  export default module;
+}
+
+declare module "*.tachyon" {
+  const defaultScope: Record<string, unknown> | ((scope: Record<string, unknown>) => Record<string, unknown>);
+  export default defaultScope;
+  export const scope: Record<string, unknown> | ((scope: Record<string, unknown>) => Record<string, unknown>);
+  export const templateHtml: string;
+  export const hydrationBoundaries: unknown[];
+  export const componentBoundaries: unknown[];
+  export const bind: (root: Element, scope: Record<string, unknown>) => void | (() => void);
+}
+
+declare module "*.tachyon?raw" {
+  const source: string;
+  export default source;
+}
+
+declare module "*.tachyon?client" {
+  export const templateHtml: string;
+  export const hydrationBoundaries: unknown[];
+  export const componentBoundaries: unknown[];
+  export const bind: (root: Element, scope: Record<string, unknown>) => void | (() => void);
+}
+
+declare module "*.tachyon?server" {
+  export const hydrationBoundaries: unknown[];
+  export const renderHydrationState: (id: string, state: unknown) => string;
+  export const render: (scope: Record<string, unknown>) => string;
+}
+
+declare module "*.tachyon?stream" {
+  export const stream: (scope: Record<string, unknown>) => AsyncIterable<string>;
+}
+
+declare module "*.tachyon?entry" {
+  const module: Record<string, unknown>;
+  export default module;
+}
+
+declare module "*.tachyon.html" {
+  const defaultScope: Record<string, unknown> | ((scope: Record<string, unknown>) => Record<string, unknown>);
+  export default defaultScope;
+  export const scope: Record<string, unknown> | ((scope: Record<string, unknown>) => Record<string, unknown>);
+  export const templateHtml: string;
+  export const hydrationBoundaries: unknown[];
+  export const componentBoundaries: unknown[];
+  export const bind: (root: Element, scope: Record<string, unknown>) => void | (() => void);
+}
+
+declare module "*.tachyon.html?raw" {
+  const source: string;
+  export default source;
+}
+
+declare module "*.tachyon.html?client" {
+  export const templateHtml: string;
+  export const hydrationBoundaries: unknown[];
+  export const componentBoundaries: unknown[];
+  export const bind: (root: Element, scope: Record<string, unknown>) => void | (() => void);
+}
+
+declare module "*.tachyon.html?server" {
+  export const hydrationBoundaries: unknown[];
+  export const renderHydrationState: (id: string, state: unknown) => string;
+  export const render: (scope: Record<string, unknown>) => string;
+}
+
+declare module "*.tachyon.html?stream" {
+  export const stream: (scope: Record<string, unknown>) => AsyncIterable<string>;
+}
+
+declare module "*.tachyon.html?entry" {
+  const module: Record<string, unknown>;
+  export default module;
+}

package/dist/testing.d.ts

@@ -0,0 +1,14 @@
+import type { TachyonApp } from "./app.js";
+import { type RouteDefinition, type RouteRenderOptions, type RouteRenderResult } from "./router.js";
+export declare const renderRouteForTest: (routes: readonly RouteDefinition[], url: string, options?: RouteRenderOptions) => Promise<RouteRenderResult>;
+export type RouteParityCase = {
+    path: string;
+    clientHtml: string;
+};
+export declare const assertRouteParity: (routes: readonly RouteDefinition[], cases: readonly RouteParityCase[], options?: RouteRenderOptions) => Promise<void>;
+export declare const renderAppForTest: (app: TachyonApp, path: string) => string;
+export declare const assertAppHtml: (app: TachyonApp, path: string, expectedFragments: readonly string[]) => void;
+export type RenderTdForTestOptions = {
+    locale?: string;
+};
+export declare const renderTdForTest: (templatePath: string, scope?: Record<string, unknown>, options?: RenderTdForTestOptions) => Promise<string>;

package/dist/testing.js

@@ -0,0 +1,36 @@
+import { readFile } from "node:fs/promises";
+import { diagnoseTachyonSfc, formatDiagnostic } from "./diagnostics.js";
+import { renderServerTemplate } from "./compiler/index.js";
+import { renderRoute } from "./router.js";
+export const renderRouteForTest = async (routes, url, options = {}) => {
+    const result = await renderRoute(routes, new URL(url, "https://example.test"), options);
+    if (!result.ok) {
+        throw new Error(result.error.message);
+    }
+    return result.value;
+};
+export const assertRouteParity = async (routes, cases, options = {}) => {
+    for (const testCase of cases) {
+        const rendered = await renderRouteForTest(routes, testCase.path, options);
+        if (rendered.html !== testCase.clientHtml) {
+            throw new Error(`Route parity mismatch for ${testCase.path}: expected ${rendered.html}, received ${testCase.clientHtml}`);
+        }
+    }
+};
+export const renderAppForTest = (app, path) => app.renderDocument(path);
+export const assertAppHtml = (app, path, expectedFragments) => {
+    const html = renderAppForTest(app, path);
+    const missing = expectedFragments.filter((fragment) => !html.includes(fragment));
+    if (missing.length > 0) {
+        throw new Error(`App HTML assertion failed for ${path}: missing ${missing.join(", ")}`);
+    }
+};
+export const renderTdForTest = async (templatePath, scope = {}, options = {}) => {
+    const source = await readFile(templatePath, "utf8");
+    const result = diagnoseTachyonSfc(source);
+    if (!result.ok) {
+        throw new Error(formatDiagnostic(result.error, templatePath));
+    }
+    const defaultScope = options.locale === undefined ? {} : { locale: options.locale };
+    return renderServerTemplate(result.value.template, { ...defaultScope, ...scope });
+};

package/dist/typed.d.ts

@@ -0,0 +1,9 @@
+export type TemplateScope = Record<string, unknown>;
+export type TypedTemplate<Scope extends TemplateScope, Source extends string = string> = {
+    source: Source;
+    __scope?: (scope: Scope) => void;
+};
+export declare const defineTemplate: <Scope extends TemplateScope, const Source extends string>(source: Source) => TypedTemplate<Scope, Source>;
+export declare const templateScope: <Scope extends TemplateScope>() => {
+    define: <const Source extends string>(source: Source) => TypedTemplate<Scope, Source>;
+};

package/dist/typed.js

@@ -0,0 +1,4 @@
+export const defineTemplate = (source) => ({ source });
+export const templateScope = () => ({
+    define: (source) => defineTemplate(source),
+});

package/dist/vite.d.ts

@@ -0,0 +1,84 @@
+import type { Plugin } from "vite";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type NodeFetchHandlerOptions, type StaticAssetOptions } from "./adapters/node.js";
+import { type TachyonApp, type TachyonAppDefinition } from "./app.js";
+import { type HtmlWhitespacePolicy } from "./html-whitespace.js";
+import type { TemplateWhitespacePolicy } from "./compiler/types.js";
+import { type Result } from "./result.js";
+import { type SourceMap } from "./source-map.js";
+export type TachyonDomViteOptions = {
+    include?: RegExp;
+    target?: "client" | "server" | "stream";
+    reactive?: boolean;
+    templateWhitespace?: TemplateWhitespacePolicy;
+    sourcemap?: boolean;
+    productionSourceMap?: boolean;
+    requestLog?: boolean | TachyonDomRequestLogOptions;
+    declarationOutput?: false | ((id: string) => string | undefined);
+    onSourceMap?: (artifact: {
+        id: string;
+        code: string;
+        map: SourceMap;
+        source: string;
+    }) => void | Promise<void>;
+};
+export type TachyonDomRequestLogOptions = {
+    enabled?: boolean;
+    includeQuery?: boolean;
+    logger?: (message: string) => void;
+};
+export type TachyonDomRouteModule = {
+    id: string;
+    path: string;
+    module: string;
+};
+export type TachyonDomRoutesViteOptions = {
+    routes?: readonly TachyonDomRouteModule[];
+    files?: readonly string[];
+    rootDir?: string;
+    virtualId?: string;
+};
+export type TachyonAppViteOptions = {
+    appScript?: string;
+    htmlWhitespace?: HtmlWhitespacePolicy;
+    /** @deprecated Use `htmlWhitespace` instead. */
+    minifyHtml?: boolean;
+};
+export type TachyonRouteAppOptions = Omit<TachyonAppDefinition, "pages"> & {
+    routesDir: string;
+};
+export declare const loadRouteApp: ({ routesDir, ...definition }: TachyonRouteAppOptions) => Promise<TachyonApp>;
+export type TachyonSsrContext = {
+    clientScript?: string;
+};
+export type TachyonSsrFetchHandler = (request: Request, context: TachyonSsrContext) => Response | Promise<Response>;
+export type TachyonSsrBypass = (url: URL, request: IncomingMessage) => boolean;
+export type TachyonSsrMiddlewareOptions = Omit<NodeFetchHandlerOptions, "fetch"> & {
+    fetch: TachyonSsrFetchHandler;
+    clientScript?: string | ((request: Request) => string | undefined | Promise<string | undefined>);
+    bypass?: TachyonSsrBypass;
+};
+export type TachyonSsrViteOptions = Omit<TachyonSsrMiddlewareOptions, "staticAssets"> & {
+    staticAssets?: StaticAssetOptions | false;
+};
+export type TachyonSsrMiddleware = (request: IncomingMessage, response: ServerResponse, next: (error?: unknown) => void) => void;
+export type CloudflarePagesPackageOptions = {
+    entry: string;
+    outDir: string;
+    assetsDir?: string;
+    exportName?: string;
+    fallthroughStatuses?: readonly number[];
+    runtimeEnvKeys?: readonly string[];
+};
+export type CloudflarePagesPackageResult = {
+    outDir: string;
+    workerPath: string;
+};
+export declare const packageCloudflarePages: (options: CloudflarePagesPackageOptions) => Promise<Result<CloudflarePagesPackageResult, string>>;
+export declare const tachyonDom: (options?: TachyonDomViteOptions) => Plugin;
+export declare const tachyonDomRoutes: (options: TachyonDomRoutesViteOptions) => Plugin;
+export declare const isViteSsrPassthroughRequest: (url: URL) => boolean;
+export declare const createTachyonSsrMiddleware: (options: TachyonSsrMiddlewareOptions) => TachyonSsrMiddleware;
+export declare const tachyonSsr: (options: TachyonSsrViteOptions) => Plugin;
+export declare const tachyonApp: (app: TachyonApp, options?: TachyonAppViteOptions) => Plugin;
+export default tachyonDom;