tachyon-dom 0.1.0

package/dist/adapters/workers.js

@@ -0,0 +1,272 @@
+import { renderRouteWithBindings, renderRouteStreamWithBindings, } from "../router.js";
+const mergeHeaders = (base, extra) => {
+    const headers = new Headers(base);
+    extra?.forEach((value, key) => headers.set(key, value));
+    return headers;
+};
+const withExtraHeaders = (response, ...extras) => {
+    let headers = new Headers(response.headers);
+    for (const extra of extras) {
+        headers = mergeHeaders(headers, extra);
+    }
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+};
+export const defineStaticRoute = (route) => route;
+const findStaticRoute = (routes, method, url) => routes?.find((route) => {
+    const methods = route.methods ?? ["GET", "HEAD"];
+    const path = route.path.includes("?") ? `${url.pathname}${url.search}` : url.search ? "" : url.pathname;
+    return methods.includes(method) && route.path === path;
+});
+const byteLength = (value) => new TextEncoder().encode(value).byteLength;
+const headersForStaticRoute = (route, extra) => {
+    const headers = mergeHeaders(new Headers(route.headers), extra);
+    if (!headers.has("content-type")) {
+        headers.set("content-type", "text/html; charset=utf-8");
+    }
+    if (!headers.has("content-length")) {
+        headers.set("content-length", String(byteLength(route.body)));
+    }
+    return headers;
+};
+const responseForStaticRoute = (route, request, securityHeaders) => new Response(request.method === "HEAD" ? null : route.body, {
+    status: route.status ?? 200,
+    headers: headersForStaticRoute(route, securityHeaders),
+});
+const now = () => globalThis.performance?.now() ?? Date.now();
+const routePatternFor = (match) => match.branch.at(-1)?.path ?? match.pathname;
+const routeIdFor = (match) => match.route.id ?? routePatternFor(match);
+const createRequestState = (request, observability) => {
+    const url = new URL(request.url);
+    return {
+        request,
+        method: request.method,
+        path: url.pathname,
+        adapter: observability?.adapter ?? "workers",
+        ...(observability?.runtime ? { runtime: observability.runtime } : {}),
+        ...(observability?.metadata ? { metadata: observability.metadata } : {}),
+        startedAt: now(),
+    };
+};
+const emitRequestStart = async (observability, state) => {
+    await observability?.onRequestStart?.({ type: "request_start", ...state });
+};
+const emitRouteMatched = async (observability, state, match) => {
+    const routePattern = routePatternFor(match);
+    state.routeId = routeIdFor(match);
+    state.routePattern = routePattern;
+    await observability?.onRouteMatched?.({
+        type: "route_matched",
+        ...state,
+        routeId: state.routeId,
+        routePattern,
+        matchedRoute: match,
+    });
+};
+const emitResponse = async (observability, state, response, failedBeforeRouteDispatch) => {
+    await observability?.onResponse?.({
+        type: "response",
+        ...state,
+        status: response.status,
+        failedBeforeRouteDispatch,
+        durationMs: now() - state.startedAt,
+    });
+};
+const emitError = async (observability, state, error, failedBeforeRouteDispatch) => {
+    await observability?.onError?.({
+        type: "error",
+        ...state,
+        error,
+        failedBeforeRouteDispatch,
+        durationMs: now() - state.startedAt,
+    });
+};
+const routeObservabilityHooks = (hooks, observability, state) => {
+    if (!observability) {
+        return hooks;
+    }
+    return {
+        ...hooks,
+        onMatch: async (context) => {
+            await hooks?.onMatch?.(context);
+            await emitRouteMatched(observability, state, context.match);
+        },
+        onError: async (context) => {
+            await hooks?.onError?.(context);
+            await emitError(observability, state, context.error, false);
+        },
+    };
+};
+const normalizeBasePath = (basePath) => {
+    if (!basePath || basePath === "/") {
+        return basePath;
+    }
+    return basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+};
+const matchesBasePath = (pathname, basePath) => {
+    const normalized = normalizeBasePath(basePath);
+    return !normalized || normalized === "/" || pathname === normalized || pathname.startsWith(`${normalized}/`);
+};
+const isWorkersAssetsBinding = (value) => Boolean(value && typeof value === "object" && typeof value.fetch === "function");
+const resolveAssetsBinding = (options, env) => {
+    if (!options) {
+        return undefined;
+    }
+    if (options.binding) {
+        return options.binding;
+    }
+    const bindingName = options.bindingName ?? "ASSETS";
+    const candidate = env && typeof env === "object" ? env[bindingName] : undefined;
+    return isWorkersAssetsBinding(candidate) ? candidate : undefined;
+};
+const responseForAsset = async (options, request, env) => {
+    const assetOptions = options.assets;
+    if (!assetOptions) {
+        return undefined;
+    }
+    const url = new URL(request.url);
+    if (!matchesBasePath(url.pathname, assetOptions.basePath)) {
+        return undefined;
+    }
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        return withExtraHeaders(new Response("Method Not Allowed", { status: 405, headers: { allow: "GET, HEAD" } }), options.securityHeaders);
+    }
+    const binding = resolveAssetsBinding(assetOptions, env);
+    if (!binding) {
+        return undefined;
+    }
+    const response = await binding.fetch(request);
+    const fallthroughStatuses = assetOptions.fallthroughStatuses ?? (assetOptions.basePath ? [] : [404]);
+    if (fallthroughStatuses.includes(response.status)) {
+        return undefined;
+    }
+    return withExtraHeaders(response, new Headers(assetOptions.headers), options.securityHeaders);
+};
+export const workersStreamFromChunks = (chunks) => {
+    const iterator = chunks[Symbol.asyncIterator]();
+    const encoder = new TextEncoder();
+    let pendingHighSurrogate = "";
+    return new ReadableStream({
+        async pull(controller) {
+            while (true) {
+                const next = await iterator.next();
+                if (next.done) {
+                    if (pendingHighSurrogate)
+                        controller.enqueue(encoder.encode(pendingHighSurrogate));
+                    pendingHighSurrogate = "";
+                    controller.close();
+                    return;
+                }
+                let value = `${pendingHighSurrogate}${next.value}`;
+                pendingHighSurrogate = "";
+                const finalCodeUnit = value.charCodeAt(value.length - 1);
+                if (finalCodeUnit >= 0xd800 && finalCodeUnit <= 0xdbff) {
+                    pendingHighSurrogate = value.slice(-1);
+                    value = value.slice(0, -1);
+                }
+                if (value.length > 0) {
+                    controller.enqueue(encoder.encode(value));
+                    return;
+                }
+            }
+        },
+        async cancel() {
+            await iterator.return?.();
+        },
+    });
+};
+const responseFor = async (options, request, env) => {
+    const state = createRequestState(request, options.observability);
+    await emitRequestStart(options.observability, state);
+    const staticRoute = findStaticRoute(options.staticRoutes, request.method, new URL(request.url));
+    if (staticRoute) {
+        state.routeId = staticRoute.path;
+        state.routePattern = staticRoute.path;
+        const response = responseForStaticRoute(staticRoute, request, options.securityHeaders);
+        await emitResponse(options.observability, state, response, false);
+        return response;
+    }
+    try {
+        const asset = await responseForAsset(options, request, env);
+        if (asset) {
+            const response = asset;
+            await emitResponse(options.observability, state, response, false);
+            return response;
+        }
+        const hooks = routeObservabilityHooks(options.hooks, options.observability, state);
+        const renderOptions = {
+            ...options,
+            bindings: env,
+            middleware: options.middleware,
+            ...(hooks ? { hooks } : {}),
+        };
+        if (options.streaming) {
+            const result = await renderRouteStreamWithBindings(options.routes, request, renderOptions);
+            if (!result.ok) {
+                const response = new Response(result.error.message, { status: result.error.status });
+                await emitResponse(options.observability, state, response, true);
+                return response;
+            }
+            const stream = workersStreamFromChunks(result.value.chunks);
+            const response = new Response(stream, {
+                status: result.value.status,
+                headers: mergeHeaders(result.value.headers, options.securityHeaders),
+            });
+            await emitResponse(options.observability, state, response, state.routeId === undefined);
+            return response;
+        }
+        const result = await renderRouteWithBindings(options.routes, request, renderOptions);
+        if (!result.ok) {
+            const response = new Response(result.error.message, { status: result.error.status });
+            await emitResponse(options.observability, state, response, true);
+            return response;
+        }
+        const response = new Response(result.value.responseBody ?? result.value.html, {
+            status: result.value.status,
+            headers: mergeHeaders(result.value.headers, options.securityHeaders),
+        });
+        await emitResponse(options.observability, state, response, state.routeId === undefined);
+        return response;
+    }
+    catch (error) {
+        await emitError(options.observability, state, error, state.routeId === undefined);
+        throw error;
+    }
+};
+const responseForFetch = async (options, request, env) => {
+    const state = createRequestState(request, options.observability);
+    await emitRequestStart(options.observability, state);
+    const staticRoute = findStaticRoute(options.staticRoutes, request.method, new URL(request.url));
+    if (staticRoute) {
+        state.routeId = staticRoute.path;
+        state.routePattern = staticRoute.path;
+        const response = responseForStaticRoute(staticRoute, request, options.securityHeaders);
+        await emitResponse(options.observability, state, response, false);
+        return response;
+    }
+    try {
+        const asset = await responseForAsset(options, request, env);
+        if (asset) {
+            await emitResponse(options.observability, state, asset, false);
+            return asset;
+        }
+        const response = withExtraHeaders(await options.fetch(request), options.securityHeaders);
+        await emitResponse(options.observability, state, response, false);
+        return response;
+    }
+    catch (error) {
+        await emitError(options.observability, state, error, state.routeId === undefined);
+        throw error;
+    }
+};
+export function createWorkersHandler(options) {
+    return {
+        fetch: (request, env) => responseFor(options, request, env),
+    };
+}
+export const createWorkersFetchHandler = (options) => ({
+    fetch: (request, env) => responseForFetch(options, request, env),
+});

package/dist/adapters.d.ts

@@ -0,0 +1,3 @@
+export { createLambdaFetchHandler, createLambdaHandler, createLambdaStreamingHandler, lambdaResponseFromWebResponse, requestFromLambdaEvent, writeWebResponseToLambdaStream, type LambdaFetchHandlerOptions, type LambdaHandlerOptions, type LambdaContextMetadata, type LambdaHttpEventV2, type LambdaHttpResponseMetadata, type LambdaProxyResponseV2, type LambdaResponseStream, type LambdaStreamingRuntime, } from "./adapters/lambda.js";
+export { createWorkersFetchHandler, createWorkersHandler, defineStaticRoute, type AdapterFetchHandler, type AdapterErrorEvent, type AdapterObservabilityHooks, type AdapterObservabilityMetadata, type AdapterRequestStartEvent, type AdapterResponseEvent, type AdapterRouteMatchedEvent, type StaticRouteDefinition, type WorkersFetchHandlerOptions, type WorkersAssetOptions, type WorkersAssetsBinding, type WorkersHandlerOptions, } from "./adapters/workers.js";
+export { createNodeFetchHandler, createNodeHandler, createStaticAssetHandler, writeNodeResponse, type NodeFetchHandlerOptions, type NodeHandlerOptions, type StaticAssetOptions, } from "./adapters/node.js";

package/dist/adapters.js

@@ -0,0 +1,3 @@
+export { createLambdaFetchHandler, createLambdaHandler, createLambdaStreamingHandler, lambdaResponseFromWebResponse, requestFromLambdaEvent, writeWebResponseToLambdaStream, } from "./adapters/lambda.js";
+export { createWorkersFetchHandler, createWorkersHandler, defineStaticRoute, } from "./adapters/workers.js";
+export { createNodeFetchHandler, createNodeHandler, createStaticAssetHandler, writeNodeResponse, } from "./adapters/node.js";

package/dist/app.d.ts

@@ -0,0 +1,98 @@
+import type { TemplateWhitespacePolicy } from "./compiler/types.js";
+import { type Result } from "./result.js";
+import type { TemplateScope, TypedTemplate } from "./typed.js";
+import { normalizeHtmlTagWhitespace, type HtmlWhitespacePolicy } from "./html-whitespace.js";
+export type { HtmlWhitespacePolicy } from "./html-whitespace.js";
+export { condenseHtmlWhitespace, normalizeHtmlTagWhitespace } from "./html-whitespace.js";
+type TachyonAppPageBase = {
+    path: string;
+    fileName: string;
+    title?: string;
+    assetPrefix?: string;
+    templateWhitespace?: TemplateWhitespacePolicy;
+};
+export type TachyonAppPage<Scope extends TemplateScope = TemplateScope> = TachyonAppPageBase & ({
+    template: string;
+    scope?: Record<string, unknown>;
+} | {
+    template: TypedTemplate<Scope>;
+    scope: Scope;
+});
+export type TachyonAppPageFile = {
+    path: string;
+    fileName: string;
+    file: string;
+    assetPrefix?: string;
+    templateWhitespace?: TemplateWhitespacePolicy;
+};
+export type TachyonAppDefinition<Pages extends readonly TachyonAppPage<any>[] = readonly TachyonAppPage[]> = {
+    lang?: string;
+    title?: string | ((page: TachyonAppPage) => string);
+    pages: Pages;
+    shell?: (context: TachyonAppShellContext) => string;
+    assets?: TachyonAppAssets | ((page: TachyonAppPage) => TachyonAppAssets);
+    notFound?: TachyonAppNotFoundPage;
+    templateWhitespace?: TemplateWhitespacePolicy;
+};
+export type TachyonAppNotFoundPage = {
+    title?: string;
+    assets?: TachyonAppAssets;
+    render: (context: {
+        path: string;
+    }) => string;
+};
+export type TachyonAppAssets = {
+    scripts?: readonly string[];
+    styles?: readonly string[];
+};
+export type TachyonAppShellContext = {
+    page: TachyonAppPage;
+    routeHtml: string;
+};
+export type TachyonAppDocumentOptions = {
+    assets?: TachyonAppAssets;
+    whitespace?: HtmlWhitespacePolicy;
+    /** @deprecated Use `whitespace: "normalize-tags"` instead. */
+    minify?: boolean;
+};
+export type TachyonAppHtmlEntry = {
+    fileName: string;
+    source: string;
+    path: string;
+};
+export type TachyonAppRenderResult = {
+    status: 200 | 404;
+    html: string;
+};
+export type TachyonApp = {
+    pages: readonly TachyonAppPage[];
+    pageForPath: (path: string) => TachyonAppPage | undefined;
+    renderRoute: (path: string) => string;
+    renderShell: (path: string) => string;
+    renderDocument: (path: string, options?: TachyonAppDocumentOptions) => string;
+    renderResponse: (path: string, options?: TachyonAppDocumentOptions) => TachyonAppRenderResult;
+    entries: (options?: TachyonAppDocumentOptions) => TachyonAppHtmlEntry[];
+};
+type ValidateTypedPageScopes<Pages extends readonly TachyonAppPage<any>[]> = {
+    readonly [Index in keyof Pages]: Pages[Index] extends {
+        template: TypedTemplate<infer Scope>;
+        scope: infer Given;
+    } ? Given extends Scope ? Pages[Index] : never : Pages[Index];
+};
+export type TemplateTypeOptions = {
+    typeName?: string;
+};
+export declare const normalizeAppPath: (path: string) => string;
+/** @deprecated Use `normalizeHtmlTagWhitespace()`. */
+export declare const minifyHtml: typeof normalizeHtmlTagWhitespace;
+export declare const renderAppDocument: (app: TachyonApp, path: string, options?: TachyonAppDocumentOptions) => string;
+export declare const renderAppResponse: (app: TachyonApp, path: string, options?: TachyonAppDocumentOptions) => TachyonAppRenderResult;
+export declare const defineApp: <const Pages extends readonly TachyonAppPage<any>[]>(definition: Omit<TachyonAppDefinition<Pages>, "pages"> & {
+    pages: ValidateTypedPageScopes<Pages>;
+}) => TachyonApp;
+export declare const pagesFromRouteFiles: (files: readonly string[], options: {
+    rootDir: string;
+    templateWhitespace?: TemplateWhitespacePolicy;
+}) => TachyonAppPageFile[];
+export declare const generateTemplateTypes: (source: string, options?: TemplateTypeOptions) => Result<string, string>;
+export declare const generateTachyonModuleTypes: (source: string, options?: TemplateTypeOptions) => Result<string, string>;

package/dist/app.js

@@ -0,0 +1,306 @@
+import { compileServerTemplate } from "./compiler/index.js";
+import { compileTachyonSfc, extractStaticSfcScope, generateSfcScriptDeclarations } from "./compiler/sfc.js";
+import { escapeHtml } from "./html-escape.js";
+import { err, ok } from "./result.js";
+import { applyHtmlWhitespace, normalizeHtmlTagWhitespace } from "./html-whitespace.js";
+export { condenseHtmlWhitespace, normalizeHtmlTagWhitespace } from "./html-whitespace.js";
+const templateExtensions = /\.(?:td|tachyon(?:\.html)?)$/;
+const ignoredIdentifiers = new Set([
+    "Array",
+    "Boolean",
+    "Date",
+    "Math",
+    "Number",
+    "Object",
+    "String",
+    "false",
+    "null",
+    "true",
+    "undefined",
+]);
+export const normalizeAppPath = (path) => {
+    if (path === "" || path === "/" || path === "/index.html") {
+        return "/";
+    }
+    const withoutIndex = path.endsWith("/index.html") ? path.slice(0, -"index.html".length) : path;
+    return withoutIndex.endsWith("/") ? withoutIndex : `${withoutIndex}/`;
+};
+const appPathMatches = (pattern, path) => {
+    const patternSegments = normalizeAppPath(pattern).split("/").filter(Boolean);
+    const pathSegments = normalizeAppPath(path).split("/").filter(Boolean);
+    for (let index = 0; index < patternSegments.length; index += 1) {
+        const patternSegment = patternSegments[index];
+        if (patternSegment?.startsWith("*"))
+            return pathSegments.length >= index + 1;
+        const pathSegment = pathSegments[index];
+        if (pathSegment === undefined)
+            return false;
+        if (!patternSegment?.startsWith(":") && patternSegment !== pathSegment)
+            return false;
+    }
+    return patternSegments.length === pathSegments.length;
+};
+/** @deprecated Use `normalizeHtmlTagWhitespace()`. */
+export const minifyHtml = normalizeHtmlTagWhitespace;
+const templateSource = (template) => typeof template === "string" ? template : template.source;
+const compilePage = (page, templateWhitespace) => {
+    const result = compileTachyonSfc(templateSource(page.template), { whitespace: templateWhitespace });
+    if (!result.ok) {
+        throw new Error(result.error.message);
+    }
+    return result.value.template;
+};
+const compilePageRenderer = (page, templateWhitespace) => compileServerTemplate(compilePage(page, templateWhitespace));
+const scopeForPage = (page) => {
+    if (page.scope)
+        return page.scope;
+    const result = extractStaticSfcScope(templateSource(page.template));
+    if (!result.ok)
+        throw new Error(result.error);
+    return result.value ?? {};
+};
+const defaultShell = ({ routeHtml }) => `<main id="app">${routeHtml}</main>`;
+const assetsForPage = (app, page, override) => {
+    if (override) {
+        return override;
+    }
+    return typeof app.assets === "function" ? app.assets(page) : (app.assets ?? {});
+};
+const titleForPage = (app, page) => {
+    if (typeof app.title === "function") {
+        return app.title(page);
+    }
+    return page.title ?? app.title ?? "Tachyon App";
+};
+export const renderAppDocument = (app, path, options = {}) => app.renderDocument(path, options);
+export const renderAppResponse = (app, path, options = {}) => app.renderResponse(path, options);
+export const defineApp = (definition) => {
+    const pages = definition.pages.map((page) => ({
+        ...page,
+        path: normalizeAppPath(page.path),
+    }));
+    const conflicts = new Map();
+    for (const page of pages) {
+        for (const key of [`path ${page.path}`, `file ${page.fileName}`]) {
+            const group = conflicts.get(key) ?? [];
+            group.push(page);
+            conflicts.set(key, group);
+        }
+    }
+    const duplicates = [...conflicts.entries()].filter(([, group]) => group.length > 1);
+    if (duplicates.length > 0) {
+        throw new Error(`Duplicate app pages:\n${duplicates.map(([key, group]) => `${key}: ${group.map((page) => page.fileName).join(", ")}`).join("\n")}`);
+    }
+    const pagesByPath = new Map();
+    for (const page of pages) {
+        if (!pagesByPath.has(page.path)) {
+            pagesByPath.set(page.path, page);
+        }
+    }
+    const renderers = new Map();
+    const pageForPath = (path) => {
+        const normalized = normalizeAppPath(path);
+        return pagesByPath.get(normalized) ?? pages.find((page) => appPathMatches(page.path, normalized));
+    };
+    const renderRoute = (path) => {
+        const page = pageForPath(path);
+        if (!page) {
+            return "";
+        }
+        const render = renderers.get(page.path) ??
+            compilePageRenderer(page, page.templateWhitespace ?? definition.templateWhitespace ?? "preserve");
+        renderers.set(page.path, render);
+        return render(scopeForPage(page));
+    };
+    const renderShell = (path) => {
+        const page = pageForPath(path);
+        if (!page) {
+            return defaultShell({ page: { path: "/", fileName: "index.html", template: "" }, routeHtml: "" });
+        }
+        const routeHtml = renderRoute(page.path);
+        return (definition.shell ?? defaultShell)({ page, routeHtml });
+    };
+    const documentFor = (page, routeHtml, options, assetsOverride) => {
+        const assets = assetsForPage(definition, page, options.assets ?? assetsOverride);
+        const shell = (definition.shell ?? defaultShell)({ page, routeHtml });
+        const html = `<!doctype html>
+<html lang="${escapeHtml(definition.lang ?? "en")}">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${escapeHtml(titleForPage(definition, page))}</title>
+    ${(assets.styles ?? []).map((href) => `<link rel="stylesheet" href="${escapeHtml(href)}" />`).join("\n    ")}
+    ${(assets.scripts ?? []).map((src) => `<script type="module" src="${escapeHtml(src)}"></script>`).join("\n    ")}
+  </head>
+  <body>
+    ${shell}
+  </body>
+</html>
+`;
+        const whitespace = options.whitespace ?? (options.minify ? "normalize-tags" : "preserve-tags");
+        return applyHtmlWhitespace(html, whitespace);
+    };
+    const renderDocument = (path, options = {}) => {
+        const page = pageForPath(path);
+        if (!page) {
+            throw new Error(`No page found for ${path}.`);
+        }
+        return documentFor(page, renderRoute(page.path), options);
+    };
+    const renderResponse = (path, options = {}) => {
+        const page = pageForPath(path);
+        if (page) {
+            return { status: 200, html: renderDocument(page.path, options) };
+        }
+        const fallback = definition.notFound;
+        const fallbackPage = {
+            path: normalizeAppPath(path),
+            fileName: "404.html",
+            title: fallback?.title ?? "Not Found",
+            template: "",
+        };
+        const routeHtml = fallback?.render({ path }) ?? "<h1>Not Found</h1>";
+        return { status: 404, html: documentFor(fallbackPage, routeHtml, options, fallback?.assets) };
+    };
+    return {
+        pages,
+        pageForPath,
+        renderDocument,
+        renderResponse,
+        renderRoute,
+        renderShell,
+        entries: (options = {}) => pages.map((page) => ({
+            fileName: page.fileName,
+            path: page.path,
+            source: renderDocument(page.path, options),
+        })),
+    };
+};
+const routeSegmentsForFile = (file, rootDir) => {
+    const relative = file.startsWith(rootDir) ? file.slice(rootDir.length).replace(/^[/\\]/, "") : file;
+    const withoutExtension = relative.replace(templateExtensions, "");
+    const parts = withoutExtension.split(/[/\\]/).filter(Boolean);
+    if (parts.at(-1) === "page") {
+        parts.pop();
+    }
+    return parts.filter((part) => part !== "index");
+};
+const segmentToRoute = (segment) => {
+    if (/^\[\.\.\.[^[\]]+\]$/.test(segment)) {
+        return `*${segment.slice(4, -1)}`;
+    }
+    if (/^\[[^[\]]+\]$/.test(segment)) {
+        return `:${segment.slice(1, -1)}`;
+    }
+    return segment;
+};
+const segmentToFileName = (segment) => segment;
+const assetPrefixForDepth = (depth) => depth <= 0 ? "." : Array.from({ length: depth }, () => "..").join("/");
+export const pagesFromRouteFiles = (files, options) => files
+    .filter((file) => templateExtensions.test(file))
+    .map((file) => {
+    const segments = routeSegmentsForFile(file, options.rootDir);
+    const path = segments.length === 0 ? "/" : `/${segments.map(segmentToRoute).join("/")}/`;
+    const fileName = segments.length === 0 ? "index.html" : `${segments.map(segmentToFileName).join("/")}/index.html`;
+    return {
+        assetPrefix: assetPrefixForDepth(segments.length),
+        file,
+        fileName,
+        path,
+        ...(options.templateWhitespace ? { templateWhitespace: options.templateWhitespace } : {}),
+    };
+});
+const collectExpressionIdentifiers = (expression, identifiers) => {
+    for (const match of expression.matchAll(/\b[$A-Z_a-z][$\w]*\b/g)) {
+        const name = match[0];
+        const previous = expression[match.index - 1];
+        if (previous === "." || ignoredIdentifiers.has(name)) {
+            continue;
+        }
+        identifiers.add(name);
+    }
+};
+const collectBindingIdentifiers = (binding, identifiers) => {
+    if (binding.kind === "event") {
+        collectExpressionIdentifiers(binding.handler, identifiers);
+        return;
+    }
+    if (binding.kind === "list") {
+        collectExpressionIdentifiers(binding.each, identifiers);
+        collectExpressionIdentifiers(binding.key, identifiers);
+        for (const child of binding.bindings) {
+            collectBindingIdentifiers(child, identifiers);
+        }
+        identifiers.delete(binding.itemName);
+        return;
+    }
+    if (binding.kind === "if") {
+        collectExpressionIdentifiers(binding.test, identifiers);
+        for (const child of binding.bindings) {
+            collectBindingIdentifiers(child, identifiers);
+        }
+        return;
+    }
+    collectExpressionIdentifiers(binding.expression, identifiers);
+};
+const collectBindingRequirements = (binding, fields) => {
+    const identifiers = new Set();
+    collectBindingIdentifiers(binding, identifiers);
+    for (const identifier of identifiers) {
+        if (!fields.has(identifier))
+            fields.set(identifier, "unknown");
+    }
+    if (binding.kind === "event" && /^[$A-Z_a-z][$\w]*$/.test(binding.handler)) {
+        fields.set(binding.handler, "(event: Event) => unknown");
+    }
+};
+export const generateTemplateTypes = (source, options = {}) => {
+    const result = compileTachyonSfc(source);
+    if (!result.ok) {
+        return err(result.error.message);
+    }
+    const identifiers = new Set();
+    for (const binding of result.value.template.client.bindings) {
+        collectBindingIdentifiers(binding, identifiers);
+    }
+    for (const store of result.value.template.client.stores) {
+        identifiers.add(store.name);
+    }
+    const typeName = options.typeName ?? "TemplateScope";
+    const fields = Array.from(identifiers)
+        .sort()
+        .map((name) => `  ${name}: unknown;`)
+        .join("\n");
+    return ok(`export type ${typeName} = {\n${fields ? `${fields}\n` : ""}};\n`);
+};
+export const generateTachyonModuleTypes = (source, options = {}) => {
+    const result = compileTachyonSfc(source);
+    if (!result.ok) {
+        return err(result.error.message);
+    }
+    const scriptTypes = generateSfcScriptDeclarations(result.value.descriptor.script);
+    if (!scriptTypes.ok) {
+        return err(scriptTypes.error);
+    }
+    const typeName = options.typeName ?? "TemplateScope";
+    const fields = new Map();
+    for (const binding of result.value.template.client.bindings)
+        collectBindingRequirements(binding, fields);
+    for (const store of result.value.template.client.stores)
+        fields.set(store.name, "unknown");
+    const requiredType = `type __TachyonRequiredScope = {\n${Array.from(fields)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, type]) => `  ${name}: ${type};`)
+        .join("\n")}\n};`;
+    const hasNamedScope = /\bexport\s+declare\s+const\s+scope\s*:/.test(scriptTypes.value);
+    const scopeType = hasNamedScope
+        ? `type __TachyonAssertScope<T extends __TachyonRequiredScope> = T;\nexport type ${typeName} = __TachyonAssertScope<ReturnType<typeof scope>>;`
+        : `export type ${typeName} = __TachyonRequiredScope;`;
+    const templateExports = [
+        `export declare const templateHtml: string;`,
+        `export declare const hydrationBoundaries: unknown[];`,
+        `export declare const componentBoundaries: unknown[];`,
+        `export declare const bind: (root: Element, scope: ${typeName}) => void | (() => void);`,
+    ].join("\n");
+    return ok([scriptTypes.value, requiredType, scopeType, templateExports].filter((part) => part.length > 0).join("\n\n") + "\n");
+};