nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/node_modules/rendu/dist/index.mjs

@@ -0,0 +1,380 @@
+import { FastResponse } from "srvx";
+
+//#region src/parser.ts
+function parseTemplate(template) {
+	if (!template) return [];
+	template = template.replace(/<script\s+server\s*>([\s\S]*?)<\/script>/gi, (_m, code) => `<?js${code}?>`);
+	template = template.replace(/{{\s*(.+)\s*}}|{{{\s*(.+)\s*}}}/g, (_m, code) => {
+		if (code[0] === "{") return `<?=${code.slice(1, -1).trim()}?>`;
+		return `<?=htmlspecialchars(${code.trim()})?>`;
+	});
+	const tokens = [];
+	const re = /<\?(?:js)?(?<equals>=)?(?<value>[\s\S]*?)\?>/g;
+	let cursor = 0;
+	let match;
+	while (match = re.exec(template)) {
+		const { equals, value } = match.groups || {};
+		const matchStart = match.index;
+		const matchEnd = matchStart + match[0].length;
+		if (matchStart > cursor) {
+			const textContent = template.slice(cursor, matchStart);
+			if (textContent) tokens.push({
+				type: "text",
+				contents: textContent
+			});
+		}
+		if (equals) tokens.push({
+			type: "expr",
+			contents: value || ""
+		});
+		else tokens.push({
+			type: "code",
+			contents: value || ""
+		});
+		cursor = matchEnd;
+	}
+	if (cursor < template.length) {
+		const remainingText = template.slice(cursor);
+		if (remainingText) tokens.push({
+			type: "text",
+			contents: remainingText
+		});
+	}
+	return tokens;
+}
+/**
+* Check if a template string contains template syntax.
+*/
+function hasTemplateSyntax(template) {
+	return /(?:<script\s+server\s*>[\s\S]*?<\/script>)|(?:<\?(?:js)?=?[\s\S]*?\?>)|(?:\{\{[\s\S]*?\}\})/i.test(template);
+}
+
+//#endregion
+//#region src/_runtime.ts
+function runtimeStream(body) {
+	return `const __chunks__ = [];const echo = (chunk) => { __chunks__.push(chunk); };${body};
+function concatStreams(chunks) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async pull(controller) {
+      for (let chunk of chunks) {
+        if (typeof chunk === 'function'){
+          chunk = chunk();
+        }
+        if (chunk instanceof Promise) {
+          chunk = await chunk;
+          if (!chunk) continue;
+          if (chunk instanceof Response){
+              chunk = chunk.body;
+          }
+          if (!(chunk instanceof ReadableStream)) {
+            controller.enqueue(chunk instanceof Uint8Array ? chunk : encoder.encode(chunk));
+            continue;
+          }
+        }
+        if (chunk instanceof ReadableStream) {
+          const reader = chunk.getReader();
+          while (true) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            controller.enqueue(value);
+          }
+          reader.releaseLock();
+        } else {
+          controller.enqueue(chunk instanceof Uint8Array ? chunk : encoder.encode(chunk));
+        }
+      }
+      controller.close();
+    },
+});
+    }
+    return concatStreams(__chunks__);
+`;
+}
+function runtimeText(body) {
+	return `const __chunks__ = [];const echo = (chunk) => { __chunks__.push(chunk); };${body};
+let __out__ = "";
+for(let chunk of __chunks__){
+  if (typeof chunk === 'function'){
+    chunk = chunk();
+  }
+  if (chunk instanceof Promise){
+    chunk = await chunk;
+  }
+  if (chunk instanceof Response){
+    chunk = chunk.body;
+  }
+  if (chunk instanceof ReadableStream){
+    const reader = chunk.getReader();
+    while(true){
+      const {value, done} = await reader.read();
+      if(done) break;
+      __out__ += typeof value === "string" ? value : new TextDecoder().decode(value);
+    }
+    reader.releaseLock();
+  } else {
+    __out__ += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+  }
+}
+return __out__;
+    `;
+}
+
+//#endregion
+//#region src/compiler.ts
+/**
+* Compile a template string into a render function.
+*
+* @example
+* ```ts
+* import { compileTemplate } from "rendu";
+*
+* const template = `
+*   <h1>{{ title }}</h1>
+*   <ul>
+*   <? for (const item of items) { ?>
+*     <li>{{ item }}</li>
+*   <? } ?>
+*   </ul>
+* `;
+*
+* const render = compileTemplate(template, { stream: false });
+*
+* const html = await render({ title: "My List", items: ["Item 1", "Item 2", "Item 3"] });
+* console.log(html);
+* // Output:
+* // <h1>My List</h1>
+* // <ul>
+* //   <li>Item 1</li>
+* //   <li>Item 2</li>
+* //   <li>Item 3</li>
+* // </ul>
+* ```
+*/
+function compileTemplate(template, opts = {}) {
+	const body = compileTemplateToString(template, opts, false);
+	const sourcemaps = opts.filename ? `\n//# sourceURL=${opts.filename}` : "";
+	try {
+		const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+		return new AsyncFunction("__context__", body + sourcemaps);
+	} catch (error) {
+		throw new SyntaxError(`Template syntax error: ${error.message}`, {});
+	}
+}
+/**
+* Compile a template string into a render function code string.
+*
+* **Note:** This function is for advanced use cases where you need the generated code as a string.
+*/
+function compileTemplateToString(template, opts, asyncWrapper) {
+	const parts = [];
+	const tokens = parseTemplate(template);
+	for (const token of tokens) switch (token.type) {
+		case "text":
+			if (opts.preserveLines) for (const line of token.contents.split("\n")) parts.push(`echo(${JSON.stringify(line + "\n")})\n`);
+			else parts.push(`echo(${JSON.stringify(token.contents)})`);
+			break;
+		case "expr":
+			parts.push(`echo(${token.contents})`);
+			break;
+		case "code":
+			parts.push(token.contents);
+			break;
+	}
+	let body = parts.join(opts.preserveLines ? ";" : "\n");
+	body = opts.contextKeys ? `const {${opts.contextKeys.join(",")}}=__context__;${body}` : `with(__context__){${body}}`;
+	body = opts.stream === false ? runtimeText(body) : runtimeStream(body);
+	return asyncWrapper === false ? body : `(async (__context__) => {${body}})`;
+}
+
+//#endregion
+//#region node_modules/.pnpm/cookie-es@2.0.0/node_modules/cookie-es/dist/index.mjs
+function parse(str, options) {
+	if (typeof str !== "string") throw new TypeError("argument str must be a string");
+	const obj = {};
+	const opt = options || {};
+	const dec = opt.decode || decode;
+	let index = 0;
+	while (index < str.length) {
+		const eqIdx = str.indexOf("=", index);
+		if (eqIdx === -1) break;
+		let endIdx = str.indexOf(";", index);
+		if (endIdx === -1) endIdx = str.length;
+		else if (endIdx < eqIdx) {
+			index = str.lastIndexOf(";", eqIdx - 1) + 1;
+			continue;
+		}
+		const key = str.slice(index, eqIdx).trim();
+		if (opt?.filter && !opt?.filter(key)) {
+			index = endIdx + 1;
+			continue;
+		}
+		if (void 0 === obj[key]) {
+			let val = str.slice(eqIdx + 1, endIdx).trim();
+			if (val.codePointAt(0) === 34) val = val.slice(1, -1);
+			obj[key] = tryDecode(val, dec);
+		}
+		index = endIdx + 1;
+	}
+	return obj;
+}
+function decode(str) {
+	return str.includes("%") ? decodeURIComponent(str) : str;
+}
+function tryDecode(str, decode2) {
+	try {
+		return decode2(str);
+	} catch {
+		return str;
+	}
+}
+const fieldContentRegExp = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
+function serialize(name, value, options) {
+	const opt = options || {};
+	const enc = opt.encode || encodeURIComponent;
+	if (typeof enc !== "function") throw new TypeError("option encode is invalid");
+	if (!fieldContentRegExp.test(name)) throw new TypeError("argument name is invalid");
+	const encodedValue = enc(value);
+	if (encodedValue && !fieldContentRegExp.test(encodedValue)) throw new TypeError("argument val is invalid");
+	let str = name + "=" + encodedValue;
+	if (void 0 !== opt.maxAge && opt.maxAge !== null) {
+		const maxAge = opt.maxAge - 0;
+		if (Number.isNaN(maxAge) || !Number.isFinite(maxAge)) throw new TypeError("option maxAge is invalid");
+		str += "; Max-Age=" + Math.floor(maxAge);
+	}
+	if (opt.domain) {
+		if (!fieldContentRegExp.test(opt.domain)) throw new TypeError("option domain is invalid");
+		str += "; Domain=" + opt.domain;
+	}
+	if (opt.path) {
+		if (!fieldContentRegExp.test(opt.path)) throw new TypeError("option path is invalid");
+		str += "; Path=" + opt.path;
+	}
+	if (opt.expires) {
+		if (!isDate(opt.expires) || Number.isNaN(opt.expires.valueOf())) throw new TypeError("option expires is invalid");
+		str += "; Expires=" + opt.expires.toUTCString();
+	}
+	if (opt.httpOnly) str += "; HttpOnly";
+	if (opt.secure) str += "; Secure";
+	if (opt.priority) switch (typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority) {
+		case "low":
+			str += "; Priority=Low";
+			break;
+		case "medium":
+			str += "; Priority=Medium";
+			break;
+		case "high":
+			str += "; Priority=High";
+			break;
+		default: throw new TypeError("option priority is invalid");
+	}
+	if (opt.sameSite) switch (typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite) {
+		case true:
+			str += "; SameSite=Strict";
+			break;
+		case "lax":
+			str += "; SameSite=Lax";
+			break;
+		case "strict":
+			str += "; SameSite=Strict";
+			break;
+		case "none":
+			str += "; SameSite=None";
+			break;
+		default: throw new TypeError("option sameSite is invalid");
+	}
+	if (opt.partitioned) str += "; Partitioned";
+	return str;
+}
+function isDate(val) {
+	return Object.prototype.toString.call(val) === "[object Date]" || val instanceof Date;
+}
+
+//#endregion
+//#region src/render.ts
+/**
+* Renders an HTML template to a Response object.
+*
+* @example
+* ```ts
+* import { compileTemplate, renderToResponse } from "rendu";
+*
+* const render = compileTemplate(template, { stream: true });
+*
+* const response = await renderToResponse(render, { request });
+* ```
+* @param htmlTemplate The compiled HTML template.
+* @param opts Options for rendering.
+* @returns A Response object.
+*/
+async function renderToResponse(htmlTemplate, opts) {
+	const ctx = createRenderContext(opts);
+	const body = await htmlTemplate(ctx);
+	if (body instanceof Response) return body;
+	return new FastResponse(body, {
+		status: ctx.$RESPONSE.status,
+		statusText: ctx.$RESPONSE.statusText,
+		headers: ctx.$RESPONSE.headers
+	});
+}
+const RENDER_CONTEXT_KEYS = [
+	"htmlspecialchars",
+	"setCookie",
+	"redirect",
+	"$REQUEST",
+	"$METHOD",
+	"$URL",
+	"$HEADERS",
+	"$COOKIES",
+	"$RESPONSE"
+];
+function createRenderContext(options) {
+	const url = new URL(options.request?.url || "http://_");
+	const response = {
+		status: 200,
+		statusText: "OK",
+		headers: new Headers({ "Content-Type": "text/html ; charset=utf-8" })
+	};
+	const $COOKIES = lazyCookies(options.request);
+	const setCookie = (name, value, sOpts = {}) => {
+		response.headers.append("Set-Cookie", serialize(name, value, sOpts));
+	};
+	const redirect = (to, status = 302) => {
+		response.status = status;
+		response.headers.set("Location", to);
+	};
+	return {
+		...options.context,
+		htmlspecialchars,
+		setCookie,
+		redirect,
+		$REQUEST: options.request,
+		$METHOD: options.request?.method,
+		$URL: url,
+		$HEADERS: options.request?.headers,
+		$COOKIES,
+		$RESPONSE: response
+	};
+}
+function lazyCookies(req) {
+	if (!req) return {};
+	let parsed;
+	return new Proxy(Object.freeze(Object.create(null)), { get(_, prop) {
+		if (typeof prop !== "string") return void 0;
+		parsed ??= parse(req.headers.get("cookie") || "");
+		return parsed[prop];
+	} });
+}
+function htmlspecialchars(s) {
+	const htmlSpecialCharsMap = {
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#39;"
+	};
+	return String(s).replace(/[&<>"']/g, (c) => htmlSpecialCharsMap[c] || c);
+}
+
+//#endregion
+export { RENDER_CONTEXT_KEYS, compileTemplate, compileTemplateToString, createRenderContext, hasTemplateSyntax, renderToResponse };

package/dist/node_modules/rendu/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "rendu",
+  "version": "0.0.7",
+  "description": "",
+  "repository": "h3js/rendu",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "types": "./dist/index.d.mts",
+  "bin": "./dist/cli.mjs",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier -c .",
+    "lint:fix": "automd && eslint . --fix && prettier -w .",
+    "prepack": "pnpm build",
+    "play": "pnpm rendu playground",
+    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
+    "rendu": "node ./src/cli.ts",
+    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "test:types": "tsc --noEmit --skipLibCheck"
+  },
+  "dependencies": {
+    "srvx": "^0.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.1",
+    "@vitest/coverage-v8": "^4.0.4",
+    "automd": "^0.4.2",
+    "changelogen": "^0.6.2",
+    "cookie-es": "^2.0.0",
+    "eslint": "^9.38.0",
+    "eslint-config-unjs": "^0.5.0",
+    "obuild": "^0.3.0",
+    "prettier": "^3.6.2",
+    "rendu": "^0.0.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.4"
+  },
+  "packageManager": "pnpm@10.19.0"
+}

package/dist/presets/_nitro/runtime/nitro-dev.mjs

@@ -1,16 +1,12 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { trapUnhandledNodeErrors } from "nitro/runtime/internal";
 import { startScheduleRunner } from "nitro/runtime/internal";
 import { Server } from "node:http";
-import nodeCrypto from "node:crypto";
 import { parentPort, threadId } from "node:worker_threads";
 import wsAdapter from "crossws/adapters/node";
 import { toNodeHandler } from "srvx/node";
 import { getSocketAddress, isSocketSupported } from "get-port-please";
-if (!globalThis.crypto) {
-  globalThis.crypto = nodeCrypto;
-}
 trapUnhandledNodeErrors();
 parentPort?.on("message", (msg) => {
   if (msg && msg.event === "shutdown") {
@@ -18,6 +14,7 @@ parentPort?.on("message", (msg) => {
   }
 });
 const nitroApp = useNitroApp();
+const nitroHooks = useNitroHooks();
 const server = new Server(toNodeHandler(nitroApp.fetch));
 let listener;
 listen().catch((error) => {
@@ -56,7 +53,7 @@ async function shutdown() {
   server.closeAllConnections?.();
   await Promise.all([
     new Promise((resolve) => listener?.close(resolve)),
-    nitroApp.hooks.callHook("close").catch(console.error)
-  ]);
+    nitroHooks.callHook("close")
+  ]).catch(console.error);
   parentPort?.postMessage({ event: "exit" });
 }

package/dist/presets/_nitro/runtime/nitro-prerenderer.mjs

@@ -1,11 +1,12 @@
 import "#nitro-internal-pollyfills";
 import consola from "consola";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { trapUnhandledNodeErrors } from "nitro/runtime/internal";
 const nitroApp = useNitroApp();
-export const appFetch = nitroApp.fetch;
-export const closePrerenderer = () => nitroApp.hooks.callHook("close");
-nitroApp.hooks.hook("error", (error, context) => {
+const nitroHooks = useNitroHooks();
+export const appFetch = nitroApp.request;
+export const closePrerenderer = () => nitroHooks.callHook("close");
+nitroHooks.hook("error", (error, context) => {
   if (!error.unhandled && error.status >= 500 && context.event?.req?.headers instanceof Headers && context.event.req.headers.get("x-nitro-prerender")) {
     consola.error(
       `[prerender error]`,

package/dist/presets/azure/runtime/azure-swa.mjs

@@ -11,7 +11,7 @@ export async function handle(context, req) {
   } else {
     url = "/api/" + (req.params.url || "");
   }
-  const response = await nitroApp.fetch(url, {
+  const response = await nitroApp.request(url, {
     method: req.method || void 0,
     // https://github.com/Azure/azure-functions-nodejs-worker/issues/294
     // https://github.com/Azure/azure-functions-host/issues/293

package/dist/presets/cloudflare/runtime/_module-handler.mjs

@@ -1,8 +1,9 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { runCronTasks } from "nitro/runtime/internal";
 export function createHandler(hooks) {
   const nitroApp = useNitroApp();
+  const nitroHooks = useNitroHooks();
   return {
     async fetch(request, env, context) {
       const ctxExt = {};
@@ -18,7 +19,7 @@ export function createHandler(hooks) {
     scheduled(controller, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:scheduled", {
+        nitroHooks.callHook("cloudflare:scheduled", {
           controller,
           env,
           context
@@ -41,7 +42,7 @@ export function createHandler(hooks) {
     email(message, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:email", {
+        nitroHooks.callHook("cloudflare:email", {
           message,
           event: message,
           // backward compat
@@ -53,7 +54,7 @@ export function createHandler(hooks) {
     queue(batch, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:queue", {
+        nitroHooks.callHook("cloudflare:queue", {
           batch,
           event: batch,
           env,
@@ -64,7 +65,7 @@ export function createHandler(hooks) {
     tail(traces, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:tail", {
+        nitroHooks.callHook("cloudflare:tail", {
           traces,
           env,
           context
@@ -74,7 +75,7 @@ export function createHandler(hooks) {
     trace(traces, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:trace", {
+        nitroHooks.callHook("cloudflare:trace", {
           traces,
           env,
           context

package/dist/presets/cloudflare/runtime/cloudflare-durable.mjs

@@ -1,12 +1,13 @@
 import "#nitro-internal-pollyfills";
 import { DurableObject } from "cloudflare:workers";
 import wsAdapter from "crossws/adapters/cloudflare";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
 import { createHandler, fetchHandler } from "./_module-handler.mjs";
 const DURABLE_BINDING = "$DurableObject";
 const DURABLE_INSTANCE = "server";
 const nitroApp = useNitroApp();
+const nitroHooks = useNitroHooks();
 const getDurableStub = (env) => {
   const binding = env[DURABLE_BINDING];
   if (!binding) {
@@ -38,7 +39,7 @@ export class $DurableObject extends DurableObject {
   constructor(state, env) {
     super(state, env);
     state.waitUntil(
-      nitroApp.hooks.callHook("cloudflare:durable:init", this, {
+      nitroHooks.callHook("cloudflare:durable:init", this, {
         state,
         env
       })
@@ -57,9 +58,7 @@ export class $DurableObject extends DurableObject {
     });
   }
   alarm() {
-    this.ctx.waitUntil(
-      nitroApp.hooks.callHook("cloudflare:durable:alarm", this)
-    );
+    this.ctx.waitUntil(nitroHooks.callHook("cloudflare:durable:alarm", this));
   }
   async webSocketMessage(client, message) {
     if (import.meta._websocket) {

package/dist/presets/cloudflare/runtime/plugin.dev.mjs

@@ -1,18 +1,15 @@
-const _proxy = _getPlatformProxy().catch((error) => {
+const proxy = await _getPlatformProxy().catch((error) => {
   console.error("Failed to initialize wrangler bindings proxy", error);
   return _createStubProxy();
-}).then((proxy) => {
-  globalThis.__env__ = proxy.env;
-  return proxy;
 });
-globalThis.__env__ = _proxy.then((proxy) => proxy.env);
+globalThis.__env__ = proxy.env;
+globalThis.__wait_until__ = proxy.ctx.waitUntil.bind(proxy.ctx);
 export default (function(nitroApp) {
   nitroApp.hooks.hook("request", async (event) => {
     event.req.context ??= {};
-    const proxy = await _proxy;
     event.req.context.cf = proxy.cf;
     event.req.context.waitUntil = proxy.ctx.waitUntil.bind(proxy.ctx);
-    const request = new Request(event.req.url);
+    const request = event.req;
     request.cf = proxy.cf;
     event.req.context.cloudflare = {
       ...event.req.context.cloudflare,
@@ -23,7 +20,7 @@ export default (function(nitroApp) {
   });
   nitroApp.hooks._hooks.request.unshift(nitroApp.hooks._hooks.request.pop());
   nitroApp.hooks.hook("close", () => {
-    return _proxy?.then((proxy) => proxy.dispose);
+    return proxy?.dispose();
   });
 });
 async function _getPlatformProxy() {
@@ -47,8 +44,8 @@ async function _getPlatformProxy() {
   if (runtimeConfig.wrangler.environment) {
     proxyOptions.environment = runtimeConfig.wrangler.environment;
   }
-  const proxy = await getPlatformProxy(proxyOptions);
-  return proxy;
+  const proxy2 = await getPlatformProxy(proxyOptions);
+  return proxy2;
 }
 function _createStubProxy() {
   return {

package/dist/presets/cloudflare/runtime/shims/workers.dev.d.mts

@@ -0,0 +1,21 @@
+export function waitUntil(promise: any): Promise<void>;
+export function withEnv(newEnv: any, fn: any): void;
+export class DurableObject extends NotImplemented {
+}
+export class RpcPromise extends NotImplemented {
+}
+export class RpcProperty extends NotImplemented {
+}
+export class RpcStub extends NotImplemented {
+}
+export class RpcTarget extends NotImplemented {
+}
+export class ServiceStub extends NotImplemented {
+}
+export class WorkerEntrypoint extends NotImplemented {
+}
+export class WorkflowEntrypoint extends NotImplemented {
+}
+declare class NotImplemented {
+}
+export {};

package/dist/presets/cloudflare/runtime/shims/workers.dev.mjs

@@ -0,0 +1,27 @@
+// Shim for "cloudflare:workers" import in dev environment
+
+// unenv shim respects __env__
+export { env } from "unenv/node/internal/process/env";
+
+export async function waitUntil(promise) {
+  await globalThis.__wait_until__?.(promise);
+}
+
+export function withEnv(newEnv, fn) {
+  throw new Error("cf.withEnv is not implemented in dev env currently.");
+}
+
+class NotImplemented {
+  constructor() {
+    throw new Error("Not implemented in dev env currently.");
+  }
+}
+
+export class DurableObject extends NotImplemented {}
+export class RpcPromise extends NotImplemented {}
+export class RpcProperty extends NotImplemented {}
+export class RpcStub extends NotImplemented {}
+export class RpcTarget extends NotImplemented {}
+export class ServiceStub extends NotImplemented {}
+export class WorkerEntrypoint extends NotImplemented {}
+export class WorkflowEntrypoint extends NotImplemented {}

package/dist/presets/node/runtime/node-server.mjs

@@ -33,7 +33,7 @@ const listener = server.listen(path ? { path } : { port, host }, (err) => {
   console.log(`Listening on ${url}`);
 });
 trapUnhandledNodeErrors();
-setupGracefulShutdown(listener, nitroApp);
+setupGracefulShutdown(listener);
 if (import.meta._websocket) {
   const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
   server.on("upgrade", handleUpgrade);