create-cloudflare 0.0.0-e3990bbf → 0.0.0-e39e9ff4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-cloudflare",
-  "version": "0.0.0-e3990bbf",
+  "version": "0.0.0-e39e9ff4",
   "description": "A CLI for creating and deploying new applications to Cloudflare.",
   "keywords": [
     "cloudflare",
@@ -30,12 +30,16 @@
     "@babel/types": "^7.21.4",
     "@clack/prompts": "^0.6.3",
     "@cloudflare/eslint-config-worker": "*",
-    "@cloudflare/workers-types": "^4.20230419.0",
+    "@cloudflare/workers-types": "^4.20240405.0",
+    "@iarna/toml": "^3.0.0",
     "@types/command-exists": "^1.2.0",
     "@types/cross-spawn": "^6.0.2",
+    "@types/deepmerge": "^2.2.0",
+    "@types/degit": "^2.8.6",
     "@types/dns2": "^2.0.3",
     "@types/esprima": "^4.0.3",
     "@types/node": "^18.15.3",
+    "@types/semver": "^7.5.1",
     "@types/which-pm-runs": "^1.0.0",
     "@types/yargs": "^17.0.22",
     "@typescript-eslint/eslint-plugin": "^5.55.0",
@@ -43,40 +47,51 @@
     "chalk": "^5.2.0",
     "command-exists": "^1.2.9",
     "cross-spawn": "^7.0.3",
+    "deepmerge": "^4.3.1",
+    "degit": "^2.8.4",
     "dns2": "^2.1.0",
+    "dotenv": "^16.0.0",
     "esbuild": "^0.17.12",
     "execa": "^7.1.1",
+    "glob": "^10.3.3",
     "haikunator": "^2.1.2",
-    "log-update": "^5.0.1",
+    "indent-string": "^5.0.0",
+    "magic-string": "^0.30.5",
     "open": "^8.4.0",
-    "pnpm": "^8.6.11",
+    "pnpm": "^8.10.0",
     "recast": "^0.22.0",
     "semver": "^7.5.1",
     "typescript": "^5.0.2",
-    "undici": "5.20.0",
+    "undici": "5.28.3",
     "vite-tsconfig-paths": "^4.0.8",
-    "vitest": "^0.30.0",
     "which-pm-runs": "^1.1.0",
+    "wrap-ansi": "^9.0.0",
     "yargs": "^17.7.1",
     "yarn": "^1.22.19",
-    "@clack/core": "^0.3.2",
-    "@types/semver": "^7.5.1",
+    "@cloudflare/cli": "1.1.1",
     "@cloudflare/workers-tsconfig": "0.0.0",
-    "wrangler": "3.8.0"
+    "wrangler": "3.51.2"
   },
   "engines": {
-    "node": ">=16.13.0"
+    "node": ">=18.14.1"
+  },
+  "workers-sdk": {
+    "prerelease": true
   },
   "scripts": {
     "build": "node -r esbuild-register scripts/build.ts",
+    "dev:codemod": "node -r esbuild-register scripts/codemodDev.ts",
     "check:lint": "eslint .",
     "check:type": "tsc",
     "lint": "eslint",
     "test:e2e:cleanup": "node -r esbuild-register scripts/e2eCleanup.ts",
-    "test:e2e:npm": "pnpm run build && TEST_PM=npm vitest run --config ./vitest-e2e.config.ts",
-    "test:e2e:pnpm": "pnpm run build && TEST_PM=pnpm vitest run --config ./vitest-e2e.config.ts",
+    "test:e2e:npm": "pnpm run build && cross-env TEST_PM=npm vitest run --config ./vitest-e2e.config.ts",
+    "test:e2e:pnpm": "pnpm run build && cross-env TEST_PM=pnpm vitest run --config ./vitest-e2e.config.ts",
+    "test:e2e:bun": "pnpm run build && cross-env TEST_PM=bun vitest run --config ./vitest-e2e.config.ts",
+    "test:e2e:yarn": "pnpm run build && cross-env TEST_PM=yarn vitest run --config ./vitest-e2e.config.ts",
     "test:unit": "vitest run --config ./vitest.config.ts",
     "test:unit:watch": "vitest --config ./vitest.config.ts",
-    "watch": "node -r esbuild-register scripts/build.ts --watch"
+    "watch": "node -r esbuild-register scripts/build.ts --watch",
+    "test:ci": "vitest run --config ./vitest.config.ts"
   }
 }

package/templates/analog/c3.ts

@@ -0,0 +1,134 @@
+import { logRaw } from "@cloudflare/cli";
+import { brandColor, dim } from "@cloudflare/cli/colors";
+import { spinner } from "@cloudflare/cli/interactive";
+import { runFrameworkGenerator } from "frameworks/index";
+import { loadTemplateSnippets, transformFile } from "helpers/codemod";
+import { getLatestTypesEntrypoint } from "helpers/compatDate";
+import { readFile, writeFile } from "helpers/files";
+import { detectPackageManager } from "helpers/packageManagers";
+import { installPackages } from "helpers/packages";
+import * as recast from "recast";
+import type { TemplateConfig } from "../../src/templates";
+import type { C3Context } from "types";
+
+const { npm, name: pm } = detectPackageManager();
+
+const generate = async (ctx: C3Context) => {
+	await runFrameworkGenerator(ctx, [
+		ctx.project.name,
+		"--template",
+		"angular-v17",
+	]);
+
+	logRaw(""); // newline
+};
+
+const configure = async (ctx: C3Context) => {
+	// Fix hoisting issues with pnpm, yarn and bun
+	if (pm === "pnpm" || pm === "yarn" || pm === "bun") {
+		const packages = [];
+		packages.push("nitropack");
+		packages.push("h3");
+		packages.push("@ngtools/webpack");
+		packages.push("@angular-devkit/build-angular");
+
+		await installPackages(packages, {
+			dev: true,
+			startText: `Installing ${packages.join(", ")}`,
+			doneText: `${brandColor("installed")} ${dim(`via \`${npm} install\``)}`,
+		});
+	}
+
+	updateViteConfig(ctx);
+	updateEnvTypes(ctx);
+};
+
+const updateEnvTypes = (ctx: C3Context) => {
+	const filepath = "env.d.ts";
+
+	const s = spinner();
+	s.start(`Updating ${filepath}`);
+
+	let file = readFile(filepath);
+
+	let typesEntrypoint = `@cloudflare/workers-types`;
+	const latestEntrypoint = getLatestTypesEntrypoint(ctx);
+	if (latestEntrypoint) {
+		typesEntrypoint += `/${latestEntrypoint}`;
+	}
+
+	// Replace placeholder with actual types entrypoint
+	file = file.replace("WORKERS_TYPES_ENTRYPOINT", typesEntrypoint);
+	writeFile("env.d.ts", file);
+
+	s.stop(`${brandColor(`updated`)} ${dim(`\`${filepath}\``)}`);
+};
+
+const updateViteConfig = (ctx: C3Context) => {
+	const b = recast.types.builders;
+	const s = spinner();
+
+	const configFile = "vite.config.ts";
+	s.start(`Updating \`${configFile}\``);
+
+	const snippets = loadTemplateSnippets(ctx);
+
+	transformFile(configFile, {
+		visitProgram(n) {
+			const lastImportIndex = n.node.body.findLastIndex(
+				(t) => t.type === "ImportDeclaration"
+			);
+			const lastImport = n.get("body", lastImportIndex);
+			lastImport.insertAfter(...snippets.devBindingsModuleTs);
+
+			return this.traverse(n);
+		},
+		visitCallExpression(n) {
+			const callee = n.node.callee as recast.types.namedTypes.Identifier;
+			if (callee.name === "analog") {
+				const pluginArguments = b.objectProperty(
+					b.identifier("nitro"),
+					b.objectExpression([
+						b.objectProperty(
+							b.identifier("preset"),
+							b.stringLiteral("cloudflare-pages")
+						),
+						b.objectProperty(
+							b.identifier("modules"),
+							b.arrayExpression([b.identifier("devBindingsModule")])
+						),
+					])
+				);
+
+				n.node.arguments = [b.objectExpression([pluginArguments])];
+			}
+
+			return this.traverse(n);
+		},
+	});
+
+	s.stop(`${brandColor(`updated`)} ${dim(`\`${configFile}\``)}`);
+};
+
+const config: TemplateConfig = {
+	configVersion: 1,
+	id: "analog",
+	platform: "pages",
+	displayName: "Analog",
+	copyFiles: {
+		path: "./templates",
+	},
+	generate,
+	configure,
+	transformPackageJson: async () => ({
+		scripts: {
+			preview: `${npm} run build && wrangler pages dev`,
+			deploy: `${npm} run build && wrangler pages deploy`,
+			"cf-typegen": `wrangler types`,
+		},
+	}),
+	devScript: "dev",
+	deployScript: "deploy",
+	previewScript: "preview",
+};
+export default config;

package/templates/analog/snippets/devBindingsModule.ts

@@ -0,0 +1,7 @@
+import { Nitro } from 'nitropack';
+
+const devBindingsModule = async (nitro: Nitro) => {
+  if (nitro.options.dev) {
+    nitro.options.plugins.push('./src/dev-bindings.ts');
+  }
+};

package/templates/analog/templates/env.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="WORKERS_TYPES_ENTRYPOINT" />
+
+declare module "h3" {
+  interface H3EventContext {
+    cf: CfProperties;
+    cloudflare: {
+      env: Env;
+      context: ExecutionContext;
+    };
+  }
+}
+
+export {};

package/templates/analog/templates/src/dev-bindings.ts

@@ -0,0 +1,18 @@
+import { NitroApp } from 'nitropack';
+import { defineNitroPlugin } from 'nitropack/dist/runtime/plugin';
+
+export default defineNitroPlugin((nitroApp: NitroApp) => {
+  nitroApp.hooks.hook('request', async (event) => {
+    const _pkg = 'wrangler'; // Bypass bundling!
+    const { getPlatformProxy } = (await import(
+      _pkg
+    )) as typeof import('wrangler');
+    const platform = await getPlatformProxy();
+
+    event.context.cf = platform['cf'];
+    event.context.cloudflare = {
+      env: platform['env'] as unknown as Env,
+      context: platform['ctx'],
+    };
+  });
+});

package/templates/analog/templates/worker-configuration.d.ts

@@ -0,0 +1,4 @@
+// Generated by Wrangler
+// After adding bindings to `wrangler.toml`, regenerate this interface via `npm run cf-typegen`
+interface Env {
+}

package/templates/analog/templates/wrangler.toml

@@ -0,0 +1,78 @@
+#:schema node_modules/wrangler/config-schema.json
+name = "<TBD>"
+compatibility_date = "<TBD>"
+pages_build_output_dir = "./dist/analog/public"
+
+# Variable bindings. These are arbitrary, plaintext strings (similar to environment variables)
+# Note: Use secrets to store sensitive data.
+# Docs:
+# - https://developers.cloudflare.com/pages/functions/bindings/#environment-variables
+# - https://developers.cloudflare.com/pages/functions/bindings/#secrets
+# [vars]
+# MY_VARIABLE = "production_value"
+
+# Bind the Workers AI model catalog. Run machine learning models, powered by serverless GPUs, on Cloudflare’s global network
+# Docs: https://developers.cloudflare.com/pages/functions/bindings/#workers-ai
+# [ai]
+# binding = "AI"
+
+# Bind a D1 database. D1 is Cloudflare’s native serverless SQL database.
+# Docs: https://developers.cloudflare.com/pages/functions/bindings/#d1-databases
+# [[d1_databases]]
+# binding = "MY_DB"
+# database_name = "my-database"
+# database_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+
+# Bind a Durable Object. Durable objects are a scale-to-zero compute primitive based on the actor model.
+# Durable Objects can live for as long as needed. Use these when you need a long-running "server", such as in realtime apps.
+# Docs: https://developers.cloudflare.com/workers/runtime-apis/durable-objects
+# [[durable_objects.bindings]]
+# name = "MY_DURABLE_OBJECT"
+# class_name = "MyDurableObject"
+# script_name = 'my-durable-object'
+
+# Bind a KV Namespace. Use KV as persistent storage for small key-value pairs.
+# Docs: https://developers.cloudflare.com/pages/functions/bindings/#kv-namespaces
+# [[kv_namespaces]]
+# binding = "MY_KV_NAMESPACE"
+# id = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+
+# Bind a Queue producer. Use this binding to schedule an arbitrary task that may be processed later by a Queue consumer.
+# Docs: https://developers.cloudflare.com/pages/functions/bindings/#queue-producers
+# [[queues.producers]]
+# binding = "MY_QUEUE"
+# queue = "my-queue"
+
+# Bind an R2 Bucket. Use R2 to store arbitrarily large blobs of data, such as files.
+# Docs: https://developers.cloudflare.com/pages/functions/bindings/#r2-buckets
+# [[r2_buckets]]
+# binding = "MY_BUCKET"
+# bucket_name = "my-bucket"
+
+# Bind another Worker service. Use this binding to call another Worker without network overhead.
+# Docs: https://developers.cloudflare.com/pages/functions/bindings/#service-bindings
+# [[services]]
+# binding = "MY_SERVICE"
+# service = "my-service"
+
+# To use different bindings for preview and production environments, follow the examples below.
+# When using environment-specific overrides for bindings, ALL bindings must be specified on a per-environment basis.
+# Docs: https://developers.cloudflare.com/pages/functions/wrangler-configuration#environment-specific-overrides
+
+######## PREVIEW environment config ########
+
+# [env.preview.vars]
+# API_KEY = "xyz789"
+
+# [[env.preview.kv_namespaces]]
+# binding = "MY_KV_NAMESPACE"
+# id = "<PREVIEW_NAMESPACE_ID>"
+
+######## PRODUCTION environment config ########
+
+# [env.production.vars]
+# API_KEY = "abc123"
+
+# [[env.production.kv_namespaces]]
+# binding = "MY_KV_NAMESPACE"
+# id = "<PRODUCTION_NAMESPACE_ID>"

package/templates/angular/c3.ts

@@ -0,0 +1,100 @@
+import { resolve } from "node:path";
+import { logRaw } from "@cloudflare/cli";
+import { brandColor, dim } from "@cloudflare/cli/colors";
+import { spinner } from "@cloudflare/cli/interactive";
+import { runFrameworkGenerator } from "frameworks/index";
+import { compatDateFlag } from "helpers/compatDate";
+import { readFile, readJSON, writeFile } from "helpers/files";
+import { detectPackageManager } from "helpers/packageManagers";
+import { installPackages } from "helpers/packages";
+import type { TemplateConfig } from "../../src/templates";
+import type { C3Context } from "types";
+
+const { npm } = detectPackageManager();
+
+const generate = async (ctx: C3Context) => {
+	await runFrameworkGenerator(ctx, [ctx.project.name, "--ssr"]);
+	logRaw("");
+};
+
+const configure = async (ctx: C3Context) => {
+	updateAngularJson(ctx);
+	await updateAppCode();
+	await installCFWorker();
+};
+
+async function installCFWorker() {
+	await installPackages(
+		["@cloudflare/workers-types", "@miniflare/tre@next", "wrangler@beta"],
+		{
+			dev: true,
+			startText: "Installing adapter dependencies",
+			doneText: `${brandColor("installed")} ${dim(`via \`${npm} install\``)}`,
+		}
+	);
+}
+async function updateAppCode() {
+	const s = spinner();
+	s.start(`Updating application code`);
+
+	// Update an app config file to:
+	// - add the `provideHttpClient(withFetch())` call to enable `fetch` usage in `HttpClient`
+	const appConfigPath = "src/app/app.config.ts";
+	const appConfig = readFile(resolve(appConfigPath));
+	const newAppConfig =
+		"import { provideHttpClient, withFetch } from '@angular/common/http';\n" +
+		appConfig.replace(
+			"providers: [",
+			"providers: [provideHttpClient(withFetch()), "
+		);
+	writeFile(resolve(appConfigPath), newAppConfig);
+	s.stop(`${brandColor(`updated`)} ${dim(appConfigPath)}`);
+
+	// Remove unwanted dependencies
+	s.start(`Updating package.json`);
+	const packageJsonPath = resolve("package.json");
+	const packageManifest = readJSON(packageJsonPath);
+
+	delete packageManifest["dependencies"]["@angular/ssr"];
+	delete packageManifest["dependencies"]["express"];
+
+	writeFile(packageJsonPath, JSON.stringify(packageManifest, null, 2));
+	s.stop(`${brandColor(`updated`)} ${dim(`\`package.json\``)}`);
+}
+
+function updateAngularJson(ctx: C3Context) {
+	const s = spinner();
+	s.start(`Updating angular.json config`);
+	const angularJson = readJSON(resolve("angular.json"));
+	// Update builder
+	const architectSection = angularJson.projects[ctx.project.name].architect;
+	architectSection.build.options.outputPath = "dist";
+	architectSection.build.options.assets.push("src/_routes.json");
+
+	writeFile(resolve("angular.json"), JSON.stringify(angularJson, null, 2));
+	s.stop(`${brandColor(`updated`)} ${dim(`\`angular.json\``)}`);
+}
+
+const config: TemplateConfig = {
+	configVersion: 1,
+	id: "angular",
+	displayName: "Angular",
+	platform: "pages",
+	copyFiles: {
+		path: "./templates",
+	},
+	devScript: "start",
+	deployScript: "deploy",
+	generate,
+	configure,
+	transformPackageJson: async () => ({
+		scripts: {
+			start: `${npm} run build && wrangler pages dev dist/cloudflare ${await compatDateFlag()} --experimental-local`,
+			build: `ng build && ${npm} run process`,
+			process:
+				"node ./tools/copy-files.mjs && node ./tools/alter-polyfills.mjs",
+			deploy: `${npm} run build && wrangler pages deploy dist/cloudflare`,
+		},
+	}),
+};
+export default config;

package/{dist/angular/templates/src/main.server.ts → templates/angular/templates/server.ts}

@@ -1,11 +1,5 @@
-import "zone.js/dist/zone-node";
-import "@angular/platform-server/init";
-
-import { bootstrapApplication } from "@angular/platform-browser";
 import { renderApplication } from "@angular/platform-server";
-
-import { AppComponent } from "./app/app.component";
-import { config } from "./app/app.config.server";
+import bootstrap from "./src/main.server";
 
 interface Env {
 	ASSETS: { fetch: typeof fetch };
@@ -14,10 +8,7 @@ interface Env {
 // We attach the Cloudflare `fetch()` handler to the global scope
 // so that we can export it when we process the Angular output.
 // See tools/bundle.mjs
-(globalThis as any).__workerFetchHandler = async function fetch(
-	request: Request,
-	env: Env
-) {
+async function workerFetchHandler(request: Request, env: Env) {
 	const url = new URL(request.url);
 	console.log("render SSR", url.href);
 
@@ -26,10 +17,18 @@ interface Env {
 	const indexResponse = await env.ASSETS.fetch(new Request(indexUrl));
 	const document = await indexResponse.text();
 
-	const content = await renderApplication(
-		() => bootstrapApplication(AppComponent, config),
-		{ document, url: url.pathname }
-	);
+	const content = await renderApplication(bootstrap, {
+		document,
+		url: url.pathname,
+	});
+
 	// console.log("rendered SSR", content);
 	return new Response(content, indexResponse);
+}
+
+export default {
+	fetch: (request: Request, env: Env) =>
+		(globalThis as any)["__zone_symbol__Promise"].resolve(
+			workerFetchHandler(request, env)
+		),
 };

package/templates/angular/templates/tools/alter-polyfills.mjs

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import { EOL } from "node:os";
+import { join } from "node:path";
+import { worker } from "./paths.mjs";
+
+/**
+ * Split by lines and comment the banner
+ * ```
+ * import { createRequire } from 'node:module';
+ * globalThis['require'] ??= createRequire(import.meta.url);
+ * ```
+ */
+const serverPolyfillsFile = join(worker, "polyfills.server.mjs");
+const serverPolyfillsData = fs
+	.readFileSync(serverPolyfillsFile, "utf8")
+	.split(/\r?\n/);
+
+for (let index = 0; index < 2; index++) {
+	if (serverPolyfillsData[index].includes("createRequire")) {
+		serverPolyfillsData[index] = "// " + serverPolyfillsData[index];
+	}
+}
+
+// Add needed polyfills
+serverPolyfillsData.unshift(`globalThis['process'] = {};`);
+
+fs.writeFileSync(serverPolyfillsFile, serverPolyfillsData.join(EOL));

package/templates/angular/templates/tools/copy-files.mjs

@@ -0,0 +1,9 @@
+// Copy the files over so that they can be uploaded by the pages publish command.
+import fs from "node:fs";
+import { join } from "node:path";
+import { client, cloudflare, ssr, worker } from "./paths.mjs";
+
+fs.cpSync(client, cloudflare, { recursive: true });
+fs.cpSync(ssr, worker, { recursive: true });
+
+fs.renameSync(join(worker, "server.mjs"), join(worker, "index.js"));

package/templates/astro/c3.ts

@@ -0,0 +1,112 @@
+import { logRaw, updateStatus } from "@cloudflare/cli";
+import { blue, brandColor, dim } from "@cloudflare/cli/colors";
+import { runFrameworkGenerator } from "frameworks/index";
+import { loadTemplateSnippets, transformFile } from "helpers/codemod";
+import { runCommand } from "helpers/command";
+import { usesTypescript } from "helpers/files";
+import { detectPackageManager } from "helpers/packageManagers";
+import * as recast from "recast";
+import type { TemplateConfig } from "../../src/templates";
+import type { C3Context, PackageJson } from "types";
+
+const { npx } = detectPackageManager();
+
+const generate = async (ctx: C3Context) => {
+	await runFrameworkGenerator(ctx, [ctx.project.name, "--no-install"]);
+
+	logRaw(""); // newline
+};
+
+const configure = async (ctx: C3Context) => {
+	await runCommand([npx, "astro", "add", "cloudflare", "-y"], {
+		silent: true,
+		startText: "Installing adapter",
+		doneText: `${brandColor("installed")} ${dim(
+			`via \`${npx} astro add cloudflare\``
+		)}`,
+	});
+
+	updateAstroConfig();
+	updateEnvDeclaration(ctx);
+};
+
+const updateAstroConfig = () => {
+	const filePath = "astro.config.mjs";
+
+	updateStatus(`Updating configuration in ${blue(filePath)}`);
+
+	transformFile(filePath, {
+		visitCallExpression: function (n) {
+			const callee = n.node.callee as recast.types.namedTypes.Identifier;
+			if (callee.name !== "cloudflare") {
+				return this.traverse(n);
+			}
+
+			const b = recast.types.builders;
+			n.node.arguments = [
+				b.objectExpression([
+					b.objectProperty(
+						b.identifier("platformProxy"),
+						b.objectExpression([
+							b.objectProperty(b.identifier("enabled"), b.booleanLiteral(true)),
+						])
+					),
+				]),
+			];
+
+			return false;
+		},
+	});
+};
+
+const updateEnvDeclaration = (ctx: C3Context) => {
+	if (!usesTypescript(ctx)) {
+		return;
+	}
+
+	const filePath = "src/env.d.ts";
+
+	updateStatus(`Adding type declarations in ${blue(filePath)}`);
+
+	transformFile(filePath, {
+		visitProgram: function (n) {
+			const snippets = loadTemplateSnippets(ctx);
+			const patch = snippets.runtimeDeclarationTs;
+			const b = recast.types.builders;
+
+			// Preserve comments with the new body
+			const comments = n.get("comments").value;
+			n.node.comments = comments.map((c: recast.types.namedTypes.CommentLine) =>
+				b.commentLine(c.value)
+			);
+
+			// Add the patch
+			n.get("body").push(...patch);
+
+			return false;
+		},
+	});
+};
+
+const config: TemplateConfig = {
+	configVersion: 1,
+	id: "astro",
+	platform: "pages",
+	displayName: "Astro",
+	copyFiles: {
+		path: "./templates",
+	},
+	devScript: "dev",
+	deployScript: "deploy",
+	previewScript: "preview",
+	generate,
+	configure,
+	transformPackageJson: async (pkgJson: PackageJson, ctx: C3Context) => ({
+		scripts: {
+			deploy: `astro build && wrangler pages deploy`,
+			preview: `astro build && wrangler pages dev`,
+			...(usesTypescript(ctx) && { "cf-typegen": `wrangler types` }),
+		},
+	}),
+};
+export default config;

package/templates/astro/snippets/runtimeDeclaration.ts

@@ -0,0 +1,5 @@
+type Runtime = import("@astrojs/cloudflare").Runtime<Env>;
+
+declare namespace App {
+	interface Locals extends Runtime {}
+}