dtwo 2.17.0 → 3.0.0-rc.14

package/dist/app/dtwo.mjs

@@ -0,0 +1,168 @@
+import { getCurrentInstance, reactive } from "kdu";
+import { createHooks } from "hookable";
+import { getContext } from "unctx";
+const dtwoAppCtx = getContext("dtwo-app");
+export const DtwoPluginIndicator = "__dtwo_plugin";
+export function createDtwoApp(options) {
+  let hydratingCount = 0;
+  const dtwoApp = {
+    provide: void 0,
+    globalName: "dtwo",
+    payload: reactive({
+      data: {},
+      state: {},
+      _errors: {},
+      ...process.client ? window.__DTWO__ : { serverRendered: true }
+    }),
+    static: {
+      data: {}
+    },
+    isHydrating: process.client,
+    deferHydration() {
+      if (!dtwoApp.isHydrating) {
+        return () => {
+        };
+      }
+      hydratingCount++;
+      let called = false;
+      return () => {
+        if (called) {
+          return;
+        }
+        called = true;
+        hydratingCount--;
+        if (hydratingCount === 0) {
+          dtwoApp.isHydrating = false;
+          return dtwoApp.callHook("app:suspense:resolve");
+        }
+      };
+    },
+    _asyncDataPromises: {},
+    _asyncData: {},
+    ...options
+  };
+  dtwoApp.hooks = createHooks();
+  dtwoApp.hook = dtwoApp.hooks.hook;
+  dtwoApp.callHook = dtwoApp.hooks.callHook;
+  dtwoApp.provide = (name, value) => {
+    const $name = "$" + name;
+    defineGetter(dtwoApp, $name, value);
+    defineGetter(dtwoApp.kduApp.config.globalProperties, $name, value);
+  };
+  defineGetter(dtwoApp.kduApp, "$dtwo", dtwoApp);
+  defineGetter(dtwoApp.kduApp.config.globalProperties, "$dtwo", dtwoApp);
+  if (process.server) {
+    if (dtwoApp.ssrContext) {
+      dtwoApp.ssrContext.dtwo = dtwoApp;
+    }
+    dtwoApp.ssrContext = dtwoApp.ssrContext || {};
+    if (dtwoApp.ssrContext.payload) {
+      Object.assign(dtwoApp.payload, dtwoApp.ssrContext.payload);
+    }
+    dtwoApp.ssrContext.payload = dtwoApp.payload;
+    dtwoApp.payload.config = {
+      public: options.ssrContext.runtimeConfig.public,
+      app: options.ssrContext.runtimeConfig.app
+    };
+  }
+  const runtimeConfig = process.server ? options.ssrContext.runtimeConfig : reactive(dtwoApp.payload.config);
+  const compatibilityConfig = new Proxy(runtimeConfig, {
+    get(target, prop) {
+      if (prop === "public") {
+        return target.public;
+      }
+      return target[prop] ?? target.public[prop];
+    },
+    set(target, prop, value) {
+      if (process.server || prop === "public" || prop === "app") {
+        return false;
+      }
+      target[prop] = value;
+      target.public[prop] = value;
+      return true;
+    }
+  });
+  dtwoApp.provide("config", compatibilityConfig);
+  return dtwoApp;
+}
+export async function applyPlugin(dtwoApp, plugin) {
+  if (typeof plugin !== "function") {
+    return;
+  }
+  const { provide } = await callWithDtwo(dtwoApp, plugin, [dtwoApp]) || {};
+  if (provide && typeof provide === "object") {
+    for (const key in provide) {
+      dtwoApp.provide(key, provide[key]);
+    }
+  }
+}
+export async function applyPlugins(dtwoApp, plugins) {
+  for (const plugin of plugins) {
+    await applyPlugin(dtwoApp, plugin);
+  }
+}
+export function normalizePlugins(_plugins) {
+  const unwrappedPlugins = [];
+  const legacyInjectPlugins = [];
+  const invalidPlugins = [];
+  const plugins = _plugins.map((plugin) => {
+    if (typeof plugin !== "function") {
+      invalidPlugins.push(plugin);
+      return null;
+    }
+    if (plugin.length > 1) {
+      legacyInjectPlugins.push(plugin);
+      return (dtwoApp) => plugin(dtwoApp, dtwoApp.provide);
+    }
+    if (!isDtwoPlugin(plugin)) {
+      unwrappedPlugins.push(plugin);
+    }
+    return plugin;
+  }).filter(Boolean);
+  if (process.dev && legacyInjectPlugins.length) {
+    console.warn("[warn] [dtwo] You are using a plugin with legacy Dtwo 2 format (context, inject) which is likely to be broken. In the future they will be ignored:", legacyInjectPlugins.map((p) => p.name || p).join(","));
+  }
+  if (process.dev && invalidPlugins.length) {
+    console.warn("[warn] [dtwo] Some plugins are not exposing a function and skipped:", invalidPlugins);
+  }
+  if (process.dev && unwrappedPlugins.length) {
+    console.warn("[warn] [dtwo] You are using a plugin that has not been wrapped in `defineDtwoPlugin`. It is advised to wrap your plugins as in the future this may enable enhancements:", unwrappedPlugins.map((p) => p.name || p).join(","));
+  }
+  return plugins;
+}
+export function defineDtwoPlugin(plugin) {
+  plugin[DtwoPluginIndicator] = true;
+  return plugin;
+}
+export function isDtwoPlugin(plugin) {
+  return typeof plugin === "function" && DtwoPluginIndicator in plugin;
+}
+export function callWithDtwo(dtwo, setup, args) {
+  const fn = () => args ? setup(...args) : setup();
+  if (process.server) {
+    return dtwoAppCtx.callAsync(dtwo, fn);
+  } else {
+    dtwoAppCtx.set(dtwo);
+    return fn();
+  }
+}
+export function useDtwoApp() {
+  const dtwoAppInstance = dtwoAppCtx.tryUse();
+  if (!dtwoAppInstance) {
+    const vm = getCurrentInstance();
+    if (!vm) {
+      throw new Error("dtwo instance unavailable");
+    }
+    return vm.appContext.app.$dtwo;
+  }
+  return dtwoAppInstance;
+}
+export function useRuntimeConfig() {
+  return useDtwoApp().$config;
+}
+function defineGetter(obj, key, val) {
+  Object.defineProperty(obj, key, { get: () => val });
+}
+export function defineAppConfig(config) {
+  return config;
+}

package/dist/app/entry.async.d.ts

@@ -0,0 +1,2 @@
+declare const entry: (ctx?: any) => Promise<any>;
+export default entry;

package/dist/app/entry.async.mjs

@@ -0,0 +1,5 @@
+const entry = process.server ? (ctx) => import("#app/entry").then((m) => m.default(ctx)) : () => import("#app/entry").then((m) => m.default);
+if (process.client) {
+  entry();
+}
+export default entry;

package/dist/app/entry.d.ts

@@ -0,0 +1,3 @@
+import '#build/css';
+declare const _default: (ctx?: any) => any;
+export default _default;

package/dist/app/entry.mjs

@@ -0,0 +1,59 @@
+import { createSSRApp, createApp, nextTick } from "kdu";
+import { $fetch } from "ofetch";
+import { baseURL } from "#build/paths.mjs";
+import { createDtwoApp, applyPlugins, normalizePlugins } from "#app";
+import "#build/css";
+import _plugins from "#build/plugins";
+import RootComponent from "#build/root-component.mjs";
+import { appRootId } from "#build/dtwo.config.mjs";
+if (!globalThis.$fetch) {
+  globalThis.$fetch = $fetch.create({
+    baseURL: baseURL()
+  });
+}
+let entry;
+const plugins = normalizePlugins(_plugins);
+if (process.server) {
+  entry = async function createDtwoAppServer(ssrContext) {
+    const kduApp = createApp(RootComponent);
+    const dtwo = createDtwoApp({ kduApp, ssrContext });
+    try {
+      await applyPlugins(dtwo, plugins);
+      await dtwo.hooks.callHook("app:created", kduApp);
+    } catch (err) {
+      await dtwo.callHook("app:error", err);
+      dtwo.payload.error = dtwo.payload.error || err;
+    }
+    return kduApp;
+  };
+}
+if (process.client) {
+  if (process.dev && import.meta.webpackHot) {
+    import.meta.webpackHot.accept();
+  }
+  entry = async function initApp() {
+    const isSSR = Boolean(window.__DTWO__?.serverRendered);
+    const kduApp = isSSR ? createSSRApp(RootComponent) : createApp(RootComponent);
+    const dtwo = createDtwoApp({ kduApp });
+    try {
+      await applyPlugins(dtwo, plugins);
+    } catch (err) {
+      await dtwo.callHook("app:error", err);
+      dtwo.payload.error = dtwo.payload.error || err;
+    }
+    try {
+      await dtwo.hooks.callHook("app:created", kduApp);
+      await dtwo.hooks.callHook("app:beforeMount", kduApp);
+      kduApp.mount("#" + appRootId);
+      await dtwo.hooks.callHook("app:mounted", kduApp);
+      await nextTick();
+    } catch (err) {
+      await dtwo.callHook("app:error", err);
+      dtwo.payload.error = dtwo.payload.error || err;
+    }
+  };
+  entry().catch((error) => {
+    console.error("Error while mounting app:", error);
+  });
+}
+export default (ctx) => entry(ctx);

package/dist/app/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference path="types/augments.d.ts" />
+export * from './dtwo';
+export * from './composables';
+export * from './components';
+export * from './config';
+export type { PageMeta } from '../pages/runtime';
+export type { MetaObject } from '../head/runtime';
+export { useHead } from '#head';
+export declare const isKdu2 = false;
+export declare const isKdu3 = true;

package/dist/app/index.mjs

@@ -0,0 +1,7 @@
+export * from "./dtwo.mjs";
+export * from "./composables/index.mjs";
+export * from "./components/index.mjs";
+export * from "./config.mjs";
+export { useHead } from "#head";
+export const isKdu2 = false;
+export const isKdu3 = true;

package/dist/app/plugins/cross-origin-prefetch.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/app/plugins/cross-origin-prefetch.client.mjs

@@ -0,0 +1,28 @@
+import { ref } from "kdu";
+import { parseURL } from "ufo";
+import { defineDtwoPlugin, useHead } from "#app";
+export default defineDtwoPlugin((dtwoApp) => {
+  const externalURLs = ref(/* @__PURE__ */ new Set());
+  useHead({
+    script: [
+      () => ({
+        type: "speculationrules",
+        innerHTML: JSON.stringify({
+          prefetch: [
+            {
+              source: "list",
+              urls: [...externalURLs.value],
+              requires: ["anonymous-client-ip-when-cross-origin"]
+            }
+          ]
+        })
+      })
+    ]
+  });
+  dtwoApp.hook("link:prefetch", (url) => {
+    const { protocol } = parseURL(url);
+    if (protocol && ["http:", "https:"].includes(protocol)) {
+      externalURLs.value.add(url);
+    }
+  });
+});

package/dist/app/plugins/debug.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/app/plugins/debug.mjs

@@ -0,0 +1,5 @@
+import { createDebugger } from "hookable";
+import { defineDtwoPlugin } from "#app";
+export default defineDtwoPlugin((dtwoApp) => {
+  createDebugger(dtwoApp.hooks, { tag: "dtwo-app" });
+});

package/dist/app/plugins/payload.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/app/plugins/payload.client.mjs

@@ -0,0 +1,22 @@
+import { parseURL } from "ufo";
+import { defineDtwoPlugin, loadPayload, isPrerendered, useRouter } from "#app";
+export default defineDtwoPlugin((dtwoApp) => {
+  if (!isPrerendered()) {
+    return;
+  }
+  dtwoApp.hooks.hook("link:prefetch", (url) => {
+    if (!parseURL(url).protocol) {
+      return loadPayload(url);
+    }
+  });
+  useRouter().beforeResolve(async (to, from) => {
+    if (to.path === from.path) {
+      return;
+    }
+    const payload = await loadPayload(to.path);
+    if (!payload) {
+      return;
+    }
+    Object.assign(dtwoApp.static.data, payload.data);
+  });
+});

package/dist/app/plugins/preload.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/app/plugins/preload.server.mjs

@@ -0,0 +1,10 @@
+import { defineDtwoPlugin } from "#app";
+export default defineDtwoPlugin((dtwoApp) => {
+  dtwoApp.kduApp.mixin({
+    beforeCreate() {
+      const { _registeredComponents } = this.$dtwo.ssrContext;
+      const { __moduleIdentifier } = this.$options;
+      _registeredComponents.add(__moduleIdentifier);
+    }
+  });
+});

package/dist/app/plugins/router.d.ts

@@ -0,0 +1,53 @@
+interface Route {
+    /** Percentage encoded pathname section of the URL. */
+    path: string;
+    /** The whole location including the `search` and `hash`. */
+    fullPath: string;
+    /** Object representation of the `search` property of the current location. */
+    query: Record<string, any>;
+    /** Hash of the current location. If present, starts with a `#`. */
+    hash: string;
+    /** Name of the matched record */
+    name: string | null | undefined;
+    /** Object of decoded params extracted from the `path`. */
+    params: Record<string, any>;
+    /**
+     * The location we were initially trying to access before ending up
+     * on the current location.
+     */
+    redirectedFrom: Route | undefined;
+    /** Merged `meta` properties from all of the matched route records. */
+    meta: Record<string, any>;
+}
+type RouteGuardReturn = void | Error | string | false;
+interface RouterHooks {
+    'resolve:before': (to: Route, from: Route) => RouteGuardReturn | Promise<RouteGuardReturn>;
+    'navigate:before': (to: Route, from: Route) => RouteGuardReturn | Promise<RouteGuardReturn>;
+    'navigate:after': (to: Route, from: Route) => void | Promise<void>;
+    'error': (err: any) => void | Promise<void>;
+}
+interface Router {
+    currentRoute: Route;
+    isReady: () => Promise<void>;
+    options: {};
+    install: () => Promise<void>;
+    push: (url: string) => Promise<void>;
+    replace: (url: string) => Promise<void>;
+    back: () => void;
+    go: (delta: number) => void;
+    forward: () => void;
+    beforeResolve: (guard: RouterHooks['resolve:before']) => () => void;
+    beforeEach: (guard: RouterHooks['navigate:before']) => () => void;
+    afterEach: (guard: RouterHooks['navigate:after']) => () => void;
+    onError: (handler: RouterHooks['error']) => () => void;
+    resolve: (url: string | Partial<Route>) => Route;
+    addRoute: (parentName: string, route: Route) => void;
+    getRoutes: () => any[];
+    hasRoute: (name: string) => boolean;
+    removeRoute: (name: string) => void;
+}
+declare const _default: import("..").Plugin<{
+    route: Route;
+    router: Router;
+}>;
+export default _default;

package/dist/app/plugins/router.mjs

@@ -0,0 +1,176 @@
+import { reactive, h } from "kdu";
+import { parseURL, stringifyParsedURL, parseQuery, stringifyQuery, withoutBase, isEqual, joinURL } from "ufo";
+import { createError } from "h3";
+import { defineDtwoPlugin, clearError, navigateTo, showError, useRuntimeConfig, useState } from "../index.mjs";
+import { callWithDtwo } from "../dtwo.mjs";
+import { globalMiddleware } from "#build/middleware";
+function getRouteFromPath(fullPath) {
+  if (typeof fullPath === "object") {
+    fullPath = stringifyParsedURL({
+      pathname: fullPath.path || "",
+      search: stringifyQuery(fullPath.query || {}),
+      hash: fullPath.hash || ""
+    });
+  }
+  const url = parseURL(fullPath.toString());
+  return {
+    path: url.pathname,
+    fullPath,
+    query: parseQuery(url.search),
+    hash: url.hash,
+    params: {},
+    name: void 0,
+    matched: [],
+    redirectedFrom: void 0,
+    meta: {},
+    href: fullPath
+  };
+}
+export default defineDtwoPlugin((dtwoApp) => {
+  const initialURL = process.client ? withoutBase(window.location.pathname, useRuntimeConfig().app.baseURL) + window.location.search + window.location.hash : dtwoApp.ssrContext.url;
+  const routes = [];
+  const hooks = {
+    "navigate:before": [],
+    "resolve:before": [],
+    "navigate:after": [],
+    error: []
+  };
+  const registerHook = (hook, guard) => {
+    hooks[hook].push(guard);
+    return () => hooks[hook].splice(hooks[hook].indexOf(guard), 1);
+  };
+  const baseURL = useRuntimeConfig().app.baseURL;
+  const route = reactive(getRouteFromPath(initialURL));
+  async function handleNavigation(url, replace) {
+    try {
+      const to = getRouteFromPath(url);
+      for (const middleware of hooks["navigate:before"]) {
+        const result = await middleware(to, route);
+        if (result === false || result instanceof Error) {
+          return;
+        }
+        if (result) {
+          return handleNavigation(result, true);
+        }
+      }
+      for (const handler of hooks["resolve:before"]) {
+        await handler(to, route);
+      }
+      Object.assign(route, to);
+      if (process.client) {
+        window.history[replace ? "replaceState" : "pushState"]({}, "", joinURL(baseURL, to.fullPath));
+        if (!dtwoApp.isHydrating) {
+          await callWithDtwo(dtwoApp, clearError);
+        }
+      }
+      for (const middleware of hooks["navigate:after"]) {
+        await middleware(to, route);
+      }
+    } catch (err) {
+      if (process.dev && !hooks.error.length) {
+        console.warn("No error handlers registered to handle middleware errors. You can register an error handler with `router.onError()`", err);
+      }
+      for (const handler of hooks.error) {
+        await handler(err);
+      }
+    }
+  }
+  const router = {
+    currentRoute: route,
+    isReady: () => Promise.resolve(),
+    options: {},
+    install: () => Promise.resolve(),
+    push: (url) => handleNavigation(url, false),
+    replace: (url) => handleNavigation(url, true),
+    back: () => window.history.go(-1),
+    go: (delta) => window.history.go(delta),
+    forward: () => window.history.go(1),
+    beforeResolve: (guard) => registerHook("resolve:before", guard),
+    beforeEach: (guard) => registerHook("navigate:before", guard),
+    afterEach: (guard) => registerHook("navigate:after", guard),
+    onError: (handler) => registerHook("error", handler),
+    resolve: getRouteFromPath,
+    addRoute: (parentName, route2) => {
+      routes.push(route2);
+    },
+    getRoutes: () => routes,
+    hasRoute: (name) => routes.some((route2) => route2.name === name),
+    removeRoute: (name) => {
+      const index = routes.findIndex((route2) => route2.name === name);
+      if (index !== -1) {
+        routes.splice(index, 1);
+      }
+    }
+  };
+  dtwoApp.kduApp.component("RouterLink", {
+    functional: true,
+    props: {
+      to: String,
+      custom: Boolean,
+      replace: Boolean,
+      activeClass: String,
+      exactActiveClass: String,
+      ariaCurrentValue: String
+    },
+    setup: (props, { slots }) => {
+      const navigate = () => handleNavigation(props.to, props.replace);
+      return () => {
+        const route2 = router.resolve(props.to);
+        return props.custom ? slots.default?.({ href: props.to, navigate, route: route2 }) : h("a", { href: props.to, onClick: (e) => {
+          e.preventDefault();
+          return navigate();
+        } }, slots);
+      };
+    }
+  });
+  if (process.client) {
+    window.addEventListener("popstate", (event) => {
+      const location = event.target.location;
+      router.replace(location.href.replace(location.origin, ""));
+    });
+  }
+  dtwoApp._route = route;
+  dtwoApp._middleware = dtwoApp._middleware || {
+    global: [],
+    named: {}
+  };
+  const initialLayout = useState("_layout");
+  dtwoApp.hooks.hookOnce("app:created", async () => {
+    router.beforeEach(async (to, from) => {
+      to.meta = reactive(to.meta || {});
+      if (dtwoApp.isHydrating) {
+        to.meta.layout = initialLayout.value ?? to.meta.layout;
+      }
+      dtwoApp._processingMiddleware = true;
+      const middlewareEntries = /* @__PURE__ */ new Set([...globalMiddleware, ...dtwoApp._middleware.global]);
+      for (const middleware of middlewareEntries) {
+        const result = await callWithDtwo(dtwoApp, middleware, [to, from]);
+        if (process.server) {
+          if (result === false || result instanceof Error) {
+            const error = result || createError({
+              statusCode: 404,
+              statusMessage: `Page Not Found: ${initialURL}`
+            });
+            return callWithDtwo(dtwoApp, showError, [error]);
+          }
+        }
+        if (result || result === false) {
+          return result;
+        }
+      }
+    });
+    router.afterEach(() => {
+      delete dtwoApp._processingMiddleware;
+    });
+    await router.replace(initialURL);
+    if (!isEqual(route.fullPath, initialURL)) {
+      await callWithDtwo(dtwoApp, navigateTo, [route.fullPath]);
+    }
+  });
+  return {
+    provide: {
+      route,
+      router
+    }
+  };
+});

package/dist/app/types/augments.d.ts

@@ -0,0 +1,28 @@
+import { DtwoApp } from '../dtwo'
+
+declare global {
+  namespace NodeJS {
+    interface Process {
+      browser: boolean
+      client: boolean
+      dev: boolean
+      mode: 'spa' | 'universal'
+      server: boolean
+      static: boolean
+    }
+  }
+
+  interface Window {
+    __DTWO__?: Record<string, any>
+  }
+}
+
+declare module '@kdujs/runtime-core' {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface App<HostElement> {
+    $dtwo: DtwoApp
+  }
+  interface ComponentInternalInstance {
+    _dtwoOnBeforeMountCbs: Function[]
+  }
+}

package/dist/core/runtime/hole/error.d.ts

@@ -0,0 +1,3 @@
+import type { HoleErrorHandler } from 'holepack';
+declare const _default: HoleErrorHandler;
+export default _default;

package/dist/core/runtime/hole/error.mjs

@@ -0,0 +1,58 @@
+import { joinURL, withQuery } from "ufo";
+import { setResponseHeader, getRequestHeaders } from "h3";
+import { useHoleApp, useRuntimeConfig } from "#internal/hole";
+import { normalizeError, isJsonRequest } from "#internal/hole/utils";
+export default (async function errorhandler(error, event) {
+  const { stack, statusCode, statusMessage, message } = normalizeError(error);
+  const errorObject = {
+    url: event.node.req.url,
+    statusCode,
+    statusMessage,
+    message,
+    stack: process.dev && statusCode !== 404 ? `<pre>${stack.map((i) => `<span class="stack${i.internal ? " internal" : ""}">${i.text}</span>`).join("\n")}</pre>` : "",
+    data: error.data
+  };
+  event.node.res.statusCode = errorObject.statusCode !== 200 && errorObject.statusCode || 500;
+  if (errorObject.statusMessage) {
+    event.node.res.statusMessage = errorObject.statusMessage;
+  }
+  if (error.unhandled || error.fatal) {
+    const tags = [
+      "[dtwo]",
+      "[request error]",
+      error.unhandled && "[unhandled]",
+      error.fatal && "[fatal]",
+      Number(errorObject.statusCode) !== 200 && `[${errorObject.statusCode}]`
+    ].filter(Boolean).join(" ");
+    console.error(tags, errorObject.message + "\n" + stack.map((l) => "  " + l.text).join("  \n"));
+  }
+  if (isJsonRequest(event)) {
+    event.node.res.setHeader("Content-Type", "application/json");
+    event.node.res.end(JSON.stringify(errorObject));
+    return;
+  }
+  const isErrorPage = event.node.req.url?.startsWith("/__dtwo_error");
+  const res = !isErrorPage ? await useHoleApp().localFetch(withQuery(joinURL(useRuntimeConfig().app.baseURL, "/__dtwo_error"), errorObject), {
+    headers: getRequestHeaders(event),
+    redirect: "manual"
+  }).catch(() => null) : null;
+  if (!res) {
+    const { template } = process.dev ? await import("@dtwo/ui-templates/templates/error-dev.mjs") : await import("@dtwo/ui-templates/templates/error-500.mjs");
+    if (process.dev) {
+      errorObject.description = errorObject.message;
+    }
+    event.node.res.setHeader("Content-Type", "text/html;charset=UTF-8");
+    event.node.res.end(template(errorObject));
+    return;
+  }
+  for (const [header, value] of res.headers.entries()) {
+    setResponseHeader(event, header, value);
+  }
+  if (res.status && res.status !== 200) {
+    event.node.res.statusCode = res.status;
+  }
+  if (res.statusText) {
+    event.node.res.statusMessage = res.statusText;
+  }
+  event.node.res.end(await res.text());
+});

package/dist/core/runtime/hole/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function baseURL(): string;
+export declare function buildAssetsDir(): string;
+export declare function buildAssetsURL(...path: string[]): string;
+export declare function publicAssetsURL(...path: string[]): string;