@chat-de-hp/site 0.1.0

package/dist/runtime/worker-core.js

@@ -0,0 +1,619 @@
+const CHAT_DE_HP_BOOTSTRAP_PATH = "/__chat_de_hp/bootstrap";
+const CHAT_DE_HP_ADMIN_LOGIN_LINK_PATH = "/__chat_de_hp/admin-login-link";
+const CHAT_DE_HP_MEDIA_PATH = "/__chat_de_hp/media";
+const CHAT_DE_HP_AGENT_EMAIL_DOMAIN = "chat-de-hp.internal";
+const CHAT_DE_HP_AGENT_TOKEN_NAME = "Chat de HP Agent";
+const CHAT_DE_HP_API_TOKEN_SCOPES = ["admin"];
+const ADMIN_LOGIN_LINK_EXPIRES_MS = 15 * 60 * 1000;
+const DEFAULT_FORM_EMAIL_FROM = "forms@chat-de-hp.com";
+const MAX_MEDIA_BYTES = 8 * 1024 * 1024;
+const SUPPORTED_MEDIA_TYPES = new Set([
+    "image/jpeg",
+    "image/png",
+    "image/webp",
+]);
+function isCmsBootstrapPath(pathname) {
+    return (pathname === CHAT_DE_HP_BOOTSTRAP_PATH ||
+        pathname === CHAT_DE_HP_BOOTSTRAP_PATH + "/");
+}
+function isAdminLoginLinkPath(pathname) {
+    return (pathname === CHAT_DE_HP_ADMIN_LOGIN_LINK_PATH ||
+        pathname === CHAT_DE_HP_ADMIN_LOGIN_LINK_PATH + "/");
+}
+function isChatDeHpMediaPath(pathname) {
+    return (pathname === CHAT_DE_HP_MEDIA_PATH ||
+        pathname === CHAT_DE_HP_MEDIA_PATH + "/" ||
+        pathname.startsWith(CHAT_DE_HP_MEDIA_PATH + "/"));
+}
+function contentTypeForAssetPath(pathname) {
+    if (pathname.endsWith(".css")) {
+        return "text/css; charset=utf-8";
+    }
+    if (pathname.endsWith(".js") || pathname.endsWith(".mjs")) {
+        return "application/javascript; charset=utf-8";
+    }
+    if (pathname.endsWith(".json")) {
+        return "application/json; charset=utf-8";
+    }
+    if (pathname.endsWith(".svg")) {
+        return "image/svg+xml";
+    }
+    if (pathname.endsWith(".wasm")) {
+        return "application/wasm";
+    }
+    if (pathname.endsWith(".woff2")) {
+        return "font/woff2";
+    }
+    if (pathname.endsWith(".woff")) {
+        return "font/woff";
+    }
+    if (pathname.endsWith(".png")) {
+        return "image/png";
+    }
+    if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) {
+        return "image/jpeg";
+    }
+    if (pathname.endsWith(".webp")) {
+        return "image/webp";
+    }
+    if (pathname.endsWith(".gif")) {
+        return "image/gif";
+    }
+    if (pathname.endsWith(".ico")) {
+        return "image/x-icon";
+    }
+    return "application/octet-stream";
+}
+function hasStaticAssetExtension(pathname) {
+    return /\.[a-z0-9][a-z0-9-]*$/iu.test(pathname);
+}
+function withAssetContentType(response, pathname) {
+    const headers = new Headers(response.headers);
+    if (!headers.get("content-type")) {
+        headers.set("content-type", contentTypeForAssetPath(pathname));
+    }
+    return new Response(response.body, {
+        headers,
+        status: response.status,
+        statusText: response.statusText,
+    });
+}
+async function handleCmsBootstrap(request, env, context, astroHandler) {
+    if (request.method !== "POST") {
+        return jsonResponse({ error: "Method not allowed.", success: false }, 405);
+    }
+    if (!env.CHAT_DE_HP_BOOTSTRAP_SECRET ||
+        request.headers.get("x-chat-de-hp-bootstrap-secret") !==
+            env.CHAT_DE_HP_BOOTSTRAP_SECRET) {
+        return jsonResponse({ error: "Unauthorized.", success: false }, 401);
+    }
+    if (!env.DB) {
+        return jsonResponse({ error: "D1 DB binding is missing.", success: false }, 500);
+    }
+    const body = await readCmsBootstrapBody(request);
+    const siteName = body.siteName ?? env.SITE_NAME ?? "Chat de HP Site";
+    const alreadySetUp = (await getOption(env.DB, "emdash:setup_complete")) === true;
+    const setup = await ensureEmDashSetup(request, env, context, siteName, astroHandler);
+    if (!setup.ok) {
+        return jsonResponse({ error: setup.error, success: false }, 500);
+    }
+    const tablesReady = await requiredEmDashTablesExist(env.DB);
+    if (!tablesReady) {
+        return jsonResponse({
+            error: "EmDash setup did not create the required tables.",
+            success: false,
+        }, 500);
+    }
+    const adminUserId = await upsertChatDeHpAgentUser(env.DB, env);
+    await finalizeChatDeHpSetup(env.DB, request, env, siteName, alreadySetUp);
+    const token = body.createToken
+        ? await createChatDeHpApiToken(env.DB, adminUserId)
+        : null;
+    return jsonResponse({
+        adminUserId,
+        scopes: CHAT_DE_HP_API_TOKEN_SCOPES,
+        success: true,
+        token: token?.raw ?? null,
+        tokenCreated: Boolean(token),
+        tokenPrefix: token?.prefix ?? null,
+    });
+}
+async function handleChatDeHpMedia(request, env) {
+    const url = new URL(request.url);
+    if (request.method === "GET") {
+        return serveChatDeHpMedia(url, env);
+    }
+    if (request.method !== "POST") {
+        return jsonResponse({ error: "Method not allowed.", success: false }, 405);
+    }
+    if (!env.CHAT_DE_HP_BOOTSTRAP_SECRET ||
+        request.headers.get("x-chat-de-hp-bootstrap-secret") !==
+            env.CHAT_DE_HP_BOOTSTRAP_SECRET) {
+        return jsonResponse({ error: "Unauthorized.", success: false }, 401);
+    }
+    if (!env.MEDIA) {
+        return jsonResponse({ error: "MEDIA binding is missing.", success: false }, 500);
+    }
+    if (!env.DB) {
+        return jsonResponse({ error: "D1 DB binding is missing.", success: false }, 500);
+    }
+    if (!(await tableExists(env.DB, "media"))) {
+        return jsonResponse({ error: "EmDash media table is missing.", success: false }, 500);
+    }
+    const formData = await request.formData();
+    const file = formData.get("file");
+    if (!(file instanceof File)) {
+        return jsonResponse({ error: "File is required.", success: false }, 400);
+    }
+    if (!SUPPORTED_MEDIA_TYPES.has(file.type)) {
+        return jsonResponse({ error: "Unsupported media type.", success: false }, 415);
+    }
+    if (file.size <= 0 || file.size > MAX_MEDIA_BYTES) {
+        return jsonResponse({ error: "File size is not allowed.", success: false }, 413);
+    }
+    const extension = extensionForMediaType(file.type);
+    const filename = sanitizeFilename(file.name || "image" + extension);
+    const key = "chat-de-hp/uploads/" +
+        new Date().toISOString().slice(0, 10) +
+        "/" +
+        crypto.randomUUID() +
+        "-" +
+        filename;
+    const bytes = await file.arrayBuffer();
+    await env.MEDIA.put(key, bytes, {
+        customMetadata: {
+            originalFilename: filename,
+            siteId: env.SITE_ID ?? "",
+        },
+        httpMetadata: {
+            contentDisposition: 'inline; filename="' + filename + '"',
+            contentType: file.type,
+        },
+    });
+    let media;
+    try {
+        media = await registerChatDeHpMedia(env.DB, env, {
+            contentHash: await sha256BytesBase64Url(new Uint8Array(bytes)),
+            filename,
+            height: positiveIntegerFormValue(formData, "height"),
+            mimeType: file.type,
+            size: file.size,
+            storageKey: key,
+            width: positiveIntegerFormValue(formData, "width"),
+        });
+    }
+    catch (error) {
+        await env.MEDIA.delete(key);
+        throw error;
+    }
+    const publicUrl = new URL(CHAT_DE_HP_MEDIA_PATH + "/" + encodeMediaKey(key), url.origin);
+    return jsonResponse({
+        emdashMediaId: media.id,
+        filename,
+        key,
+        mediaId: media.id,
+        mimeType: file.type,
+        size: file.size,
+        storageKey: key,
+        success: true,
+        url: publicUrl.toString(),
+        width: media.width,
+        height: media.height,
+    });
+}
+async function handleAdminLoginLink(request, env) {
+    if (request.method !== "POST") {
+        return jsonResponse({ error: "Method not allowed.", success: false }, 405);
+    }
+    if (!env.CHAT_DE_HP_BOOTSTRAP_SECRET ||
+        request.headers.get("x-chat-de-hp-bootstrap-secret") !==
+            env.CHAT_DE_HP_BOOTSTRAP_SECRET) {
+        return jsonResponse({ error: "Unauthorized.", success: false }, 401);
+    }
+    if (!env.DB) {
+        return jsonResponse({ error: "D1 DB binding is missing.", success: false }, 500);
+    }
+    if (!(await tableExists(env.DB, "auth_tokens"))) {
+        return jsonResponse({ error: "EmDash auth tables are missing.", success: false }, 500);
+    }
+    const adminUserId = await upsertChatDeHpAgentUser(env.DB, env);
+    const adminUser = chatDeHpAgentUser(env);
+    const body = await readAdminLoginLinkBody(request);
+    const token = randomBase64Url(32);
+    const hash = await hashMagicLinkToken(token);
+    const now = new Date();
+    const expiresAt = new Date(now.getTime() + ADMIN_LOGIN_LINK_EXPIRES_MS).toISOString();
+    await env.DB.prepare("DELETE FROM auth_tokens WHERE user_id = ? AND type = ?")
+        .bind(adminUserId, "magic_link")
+        .run();
+    await env.DB.prepare("INSERT INTO auth_tokens " +
+        "(hash, user_id, email, type, role, invited_by, expires_at, created_at) " +
+        "VALUES (?, ?, ?, 'magic_link', NULL, NULL, ?, ?)")
+        .bind(hash, adminUserId, adminUser.email, expiresAt, now.toISOString())
+        .run();
+    const loginUrl = new URL("/_emdash/api/auth/magic-link/verify", new URL(request.url).origin);
+    loginUrl.searchParams.set("token", token);
+    loginUrl.searchParams.set("redirect", body.redirect);
+    return jsonResponse({
+        adminUserId,
+        expiresAt,
+        loginUrl: loginUrl.toString(),
+        redirect: body.redirect,
+        success: true,
+    });
+}
+async function serveChatDeHpMedia(url, env) {
+    if (!env.MEDIA) {
+        return new Response("MEDIA binding is missing.", { status: 500 });
+    }
+    const prefix = CHAT_DE_HP_MEDIA_PATH + "/";
+    if (!url.pathname.startsWith(prefix)) {
+        return new Response("Not found.", { status: 404 });
+    }
+    const key = decodeMediaKey(url.pathname.slice(prefix.length));
+    if (!key.startsWith("chat-de-hp/uploads/")) {
+        return new Response("Not found.", { status: 404 });
+    }
+    const object = await env.MEDIA.get(key);
+    if (!object) {
+        return new Response("Not found.", { status: 404 });
+    }
+    return new Response(object.body, {
+        headers: {
+            "cache-control": "public, max-age=31536000, immutable",
+            "content-disposition": object.httpMetadata?.contentDisposition ?? "inline",
+            "content-type": object.httpMetadata?.contentType ?? "application/octet-stream",
+        },
+    });
+}
+async function ensureEmDashSetup(request, env, context, siteName, astroHandler) {
+    if (!env.DB) {
+        return { error: "D1 DB binding is missing.", ok: false };
+    }
+    if ((await getOption(env.DB, "emdash:setup_complete")) === true) {
+        return { ok: true };
+    }
+    const setupUrl = new URL("/_emdash/api/setup", request.url);
+    const setupRequest = new Request(setupUrl, {
+        body: JSON.stringify({
+            includeContent: true,
+            tagline: "",
+            title: siteName,
+        }),
+        headers: {
+            "content-type": "application/json",
+        },
+        method: "POST",
+    });
+    const response = await astroHandler.fetch(setupRequest, env, context);
+    if (response.ok || response.status === 409) {
+        return { ok: true };
+    }
+    const responseText = await response.text();
+    return {
+        error: "EmDash setup failed. HTTP " +
+            response.status +
+            ": " +
+            responseText.slice(0, 500),
+        ok: false,
+    };
+}
+async function requiredEmDashTablesExist(db) {
+    return ((await tableExists(db, "options")) &&
+        (await tableExists(db, "users")) &&
+        (await tableExists(db, "_emdash_api_tokens")));
+}
+async function tableExists(db, tableName) {
+    const row = await db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+        .bind(tableName)
+        .first();
+    return Boolean(row);
+}
+async function upsertChatDeHpAgentUser(db, env) {
+    const now = new Date().toISOString();
+    const user = chatDeHpAgentUser(env);
+    await db
+        .prepare("INSERT INTO users (id, email, name, role, email_verified, disabled, data, created_at, updated_at) " +
+        "VALUES (?, ?, ?, 50, 1, 0, '{}', ?, ?) " +
+        "ON CONFLICT(email) DO UPDATE SET " +
+        "name = excluded.name, " +
+        "role = 50, " +
+        "email_verified = 1, " +
+        "disabled = 0, " +
+        "updated_at = excluded.updated_at")
+        .bind(user.id, user.email, "Chat de HP Agent", now, now)
+        .run();
+    const row = await db
+        .prepare("SELECT id FROM users WHERE email = ?")
+        .bind(user.email)
+        .first();
+    if (!row?.id) {
+        throw new Error("Failed to create the Chat de HP agent user.");
+    }
+    return row.id;
+}
+async function registerChatDeHpMedia(db, env, input) {
+    const now = new Date().toISOString();
+    const id = createMediaId();
+    const author = chatDeHpAgentUser(env);
+    await db
+        .prepare("INSERT INTO media " +
+        "(id, filename, mime_type, size, width, height, alt, caption, storage_key, content_hash, blurhash, dominant_color, status, created_at, author_id) " +
+        "VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, NULL, NULL, 'ready', ?, ?)")
+        .bind(id, input.filename, input.mimeType, input.size, input.width, input.height, input.storageKey, input.contentHash, now, author.id)
+        .run();
+    return {
+        height: input.height,
+        id,
+        width: input.width,
+    };
+}
+function chatDeHpAgentUser(env) {
+    const siteId = env.SITE_ID ?? "unknown-site";
+    const stableSiteId = stableIdentifier(siteId);
+    return {
+        email: "chat-de-hp-agent+" + stableSiteId + "@" + CHAT_DE_HP_AGENT_EMAIL_DOMAIN,
+        id: "chat_de_hp_agent_" + stableSiteId,
+    };
+}
+function createMediaId() {
+    return "chatdehp_" + crypto.randomUUID().replaceAll("-", "");
+}
+function positiveIntegerFormValue(formData, name) {
+    const value = formData.get(name);
+    if (typeof value !== "string" || value.trim() === "") {
+        return null;
+    }
+    const number = Number.parseInt(value, 10);
+    return Number.isInteger(number) && number > 0 ? number : null;
+}
+async function finalizeChatDeHpSetup(db, request, env, siteName, alreadySetUp) {
+    // First bootstrap: the name entered on the platform wins over any
+    // seed-provided default title.
+    await (alreadySetUp
+        ? setOptionIfAbsent(db, "emdash:site_title", siteName)
+        : setOption(db, "emdash:site_title", siteName));
+    await setOptionIfAbsent(db, "emdash:site_url", env.PUBLIC_URL ?? new URL(request.url).origin);
+    await setOptionIfAbsent(db, "plugin:cloudflare-email:settings:from", env.FORM_EMAIL_FROM ?? DEFAULT_FORM_EMAIL_FROM);
+    await setOption(db, "emdash:setup_complete", true);
+    await deleteOption(db, "emdash:setup_state");
+}
+async function createChatDeHpApiToken(db, userId) {
+    const raw = "ec_pat_" + randomBase64Url(32);
+    const hash = await sha256Base64Url(raw);
+    const prefix = raw.slice(0, "ec_pat_".length + 4);
+    await db
+        .prepare("DELETE FROM _emdash_api_tokens WHERE user_id = ? AND name = ?")
+        .bind(userId, CHAT_DE_HP_AGENT_TOKEN_NAME)
+        .run();
+    await db
+        .prepare("INSERT INTO _emdash_api_tokens " +
+        "(id, name, token_hash, prefix, user_id, scopes, expires_at, last_used_at) " +
+        "VALUES (?, ?, ?, ?, ?, ?, NULL, NULL)")
+        .bind(crypto.randomUUID(), CHAT_DE_HP_AGENT_TOKEN_NAME, hash, prefix, userId, JSON.stringify(CHAT_DE_HP_API_TOKEN_SCOPES))
+        .run();
+    return { prefix, raw };
+}
+async function getOption(db, name) {
+    if (!(await tableExists(db, "options"))) {
+        return null;
+    }
+    const row = await db
+        .prepare("SELECT value FROM options WHERE name = ?")
+        .bind(name)
+        .first();
+    if (!row) {
+        return null;
+    }
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return null;
+    }
+}
+async function setOption(db, name, value) {
+    await db
+        .prepare("INSERT INTO options (name, value) VALUES (?, ?) " +
+        "ON CONFLICT(name) DO UPDATE SET value = excluded.value")
+        .bind(name, JSON.stringify(value))
+        .run();
+}
+async function setOptionIfAbsent(db, name, value) {
+    await db
+        .prepare("INSERT INTO options (name, value) VALUES (?, ?) " +
+        "ON CONFLICT(name) DO NOTHING")
+        .bind(name, JSON.stringify(value))
+        .run();
+}
+async function deleteOption(db, name) {
+    await db.prepare("DELETE FROM options WHERE name = ?").bind(name).run();
+}
+async function readCmsBootstrapBody(request) {
+    try {
+        const value = (await request.json());
+        if (!value || typeof value !== "object") {
+            return { createToken: true, siteName: null };
+        }
+        const candidate = value;
+        return {
+            createToken: candidate.createToken !== false,
+            siteName: typeof candidate.siteName === "string" && candidate.siteName.trim()
+                ? candidate.siteName.trim()
+                : null,
+        };
+    }
+    catch {
+        return { createToken: true, siteName: null };
+    }
+}
+async function readAdminLoginLinkBody(request) {
+    try {
+        const value = (await request.json());
+        const candidate = value && typeof value === "object"
+            ? value
+            : {};
+        const redirect = typeof candidate.redirect === "string" &&
+            isSafeLocalRedirect(candidate.redirect)
+            ? candidate.redirect
+            : "/_emdash/admin";
+        return { redirect };
+    }
+    catch {
+        return {
+            redirect: "/_emdash/admin",
+        };
+    }
+}
+function isSafeLocalRedirect(value) {
+    return (value.startsWith("/") && !value.startsWith("//") && !value.includes("\\"));
+}
+async function sha256Base64Url(value) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+    return bytesToBase64Url(new Uint8Array(digest));
+}
+async function sha256BytesBase64Url(value) {
+    const bytes = new Uint8Array(value.byteLength);
+    bytes.set(value);
+    const digest = await crypto.subtle.digest("SHA-256", bytes.buffer);
+    return bytesToBase64Url(new Uint8Array(digest));
+}
+async function hashMagicLinkToken(token) {
+    return sha256BytesBase64Url(base64UrlToBytes(token));
+}
+function randomBase64Url(byteLength) {
+    const bytes = new Uint8Array(byteLength);
+    crypto.getRandomValues(bytes);
+    return bytesToBase64Url(bytes);
+}
+function bytesToBase64Url(bytes) {
+    let binary = "";
+    const chunkSize = 0x80_00;
+    for (let index = 0; index < bytes.length; index += chunkSize) {
+        binary += String.fromCodePoint(...bytes.subarray(index, index + chunkSize));
+    }
+    return btoa(binary)
+        .replaceAll("+", "-")
+        .replaceAll("/", "_")
+        .replaceAll("=", "");
+}
+function base64UrlToBytes(value) {
+    const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
+    const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.codePointAt(index) ?? 0;
+    }
+    return bytes;
+}
+function stableIdentifier(value) {
+    return value.toLowerCase().replaceAll(/[^a-z0-9_-]/gu, "_");
+}
+function jsonResponse(body, status = 200) {
+    // oxlint-disable-next-line unicorn/prefer-response-static-json -- preserve the established charset-bearing content type
+    return new Response(JSON.stringify(body), {
+        headers: {
+            "cache-control": "no-store",
+            "content-type": "application/json; charset=utf-8",
+        },
+        status,
+    });
+}
+function extensionForMediaType(mediaType) {
+    switch (mediaType) {
+        case "image/jpeg": {
+            return ".jpg";
+        }
+        case "image/png": {
+            return ".png";
+        }
+        case "image/webp": {
+            return ".webp";
+        }
+        default: {
+            return "";
+        }
+    }
+}
+function sanitizeFilename(value) {
+    const sanitized = value
+        .trim()
+        .replaceAll(/[^a-z0-9._-]+/giu, "-")
+        .replaceAll(/^-+|-+$/gu, "")
+        .slice(0, 96);
+    return sanitized || "image";
+}
+function encodeMediaKey(key) {
+    return key.split("/").map(encodeURIComponent).join("/");
+}
+function decodeMediaKey(key) {
+    return key.split("/").map(decodeURIComponent).join("/");
+}
+export function createChatDeHpSiteWorkerWithHandler(runtime, astroHandler) {
+    const routes = validateRuntime(runtime);
+    return {
+        async fetch(request, env, context) {
+            const url = new URL(request.url);
+            if (isCmsBootstrapPath(url.pathname)) {
+                return handleCmsBootstrap(request, env, context, astroHandler);
+            }
+            if (isAdminLoginLinkPath(url.pathname)) {
+                return handleAdminLoginLink(request, env);
+            }
+            if (isChatDeHpMediaPath(url.pathname)) {
+                return handleChatDeHpMedia(request, env);
+            }
+            const primitiveRoute = routes.get(runtimeRouteKey(request.method, url.pathname)) ??
+                routes.get(runtimeRouteKey("*", url.pathname));
+            if (primitiveRoute) {
+                return primitiveRoute.handle(request, env, context);
+            }
+            if (env.ASSETS && hasStaticAssetExtension(url.pathname)) {
+                const assetResponse = await env.ASSETS.fetch(request);
+                if (assetResponse.status !== 404) {
+                    return withAssetContentType(assetResponse, url.pathname);
+                }
+            }
+            return astroHandler.fetch(request, env, context);
+        },
+    };
+}
+function validateRuntime(runtime) {
+    if (!runtime || !Array.isArray(runtime.primitives)) {
+        throw new Error("Generated Chat de HP runtime is malformed.");
+    }
+    const primitiveIds = new Set();
+    const routes = new Map();
+    for (const primitive of runtime.primitives) {
+        if (!/^[a-z][a-z0-9-]*$/u.test(primitive.id)) {
+            throw new Error(`Runtime primitive id ${JSON.stringify(primitive.id)} is malformed.`);
+        }
+        if (primitiveIds.has(primitive.id)) {
+            throw new Error(`Runtime primitive ${primitive.id} is registered more than once.`);
+        }
+        primitiveIds.add(primitive.id);
+        for (const route of primitive.routes) {
+            validateRuntimeRoute(primitive.id, route);
+            const key = runtimeRouteKey(route.method ?? "*", route.pathname);
+            if (routes.has(key)) {
+                throw new Error(`Runtime route ${route.method ?? "*"} ${route.pathname} is registered more than once.`);
+            }
+            routes.set(key, route);
+        }
+    }
+    return routes;
+}
+function validateRuntimeRoute(primitiveId, route) {
+    if (!route.pathname.startsWith("/")) {
+        throw new Error(`Runtime primitive ${primitiveId} route must start with "/": ${route.pathname}.`);
+    }
+    if (route.pathname === "/__chat_de_hp" ||
+        route.pathname.startsWith("/__chat_de_hp/")) {
+        throw new Error(`Runtime primitive ${primitiveId} cannot claim reserved route ${route.pathname}.`);
+    }
+}
+function runtimeRouteKey(method, pathname) {
+    return `${method.toUpperCase()} ${pathname}`;
+}

package/dist/runtime/worker.d.ts

@@ -0,0 +1,5 @@
+import type { GeneratedSiteRuntime } from "./contracts.js";
+export declare function createChatDeHpSiteWorker(runtime: GeneratedSiteRuntime): {
+    fetch(request: Request, env: import("./contracts.js").ChatDeHpSiteEnv, context: import("./contracts.js").ChatDeHpExecutionContext): Promise<Response>;
+};
+//# sourceMappingURL=worker.d.ts.map

package/dist/runtime/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/runtime/worker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAG3D,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,oBAAoB;;EAErE"}

package/dist/runtime/worker.js

@@ -0,0 +1,5 @@
+import handler from "@astrojs/cloudflare/entrypoints/server";
+import { createChatDeHpSiteWorkerWithHandler } from "./worker-core.js";
+export function createChatDeHpSiteWorker(runtime) {
+    return createChatDeHpSiteWorkerWithHandler(runtime, handler);
+}