@faasjs/dev 8.0.0-beta.10

package/dist/index.mjs

@@ -0,0 +1,272 @@
+import { n as __reExport, t as __exportAll } from "./chunk-D8kEL_kv.mjs";
+import { n as isTypegenSourceFile, r as resolveServerConfig, t as generateFaasTypes } from "./typegen-BNWmP5Qp.mjs";
+import { brotliDecompressSync, gunzipSync, inflateSync } from "node:zlib";
+import { Http, Server } from "@faasjs/core";
+import { Logger, deepMerge, loadConfig, streamToObject, streamToString, streamToText } from "@faasjs/node-utils";
+import { join } from "node:path";
+
+export * from "@faasjs/core"
+
+//#region src/test.ts
+/**
+* Test wrapper for a function.
+*
+* ```ts
+* import { FuncWarper } from '@faasjs/dev'
+* import Func from '../demo.func.ts'
+*
+* const func = new FuncWarper(Func)
+*
+* expect(await func.handler()).toEqual('Hello, world')
+* ```
+*/
+var FuncWarper = class {
+	file;
+	staging;
+	logger;
+	func;
+	config;
+	plugins;
+	_handler;
+	/**
+	* @param initBy {Func} A FaasJS function
+	* ```ts
+	* import { FuncWarper } from '@faasjs/dev'
+	*
+	* new FuncWarper(__dirname + '/../demo.func.ts')
+	* ```
+	*/
+	constructor(initBy) {
+		this.staging = process.env.FaasEnv ?? "default";
+		this.logger = new Logger("TestCase");
+		this.func = initBy.default ? initBy.default : initBy;
+		if (this.func.filename) this.func.config = deepMerge(loadConfig(process.cwd(), this.func.filename, this.staging, this.logger), this.func.config);
+		this.file = this.func.filename || "";
+		this.config = this.func.config;
+		this.plugins = this.func.plugins || [];
+		for (const plugin of this.plugins) {
+			if ([
+				"handler",
+				"config",
+				"plugins",
+				"logger",
+				"mount"
+			].includes(plugin.type)) continue;
+			this[plugin.type] = plugin;
+		}
+		this._handler = this.func.export().handler;
+	}
+	async mount(handler) {
+		if (!this.func.mounted) await this.func.mount();
+		if (handler) await handler(this);
+	}
+	async handler(event = Object.create(null), context = Object.create(null)) {
+		await this.mount();
+		const response = await this._handler(event, context);
+		this.logger.debug("response: %j", response);
+		return response;
+	}
+	async JSONhandler(body, options = Object.create(null)) {
+		await this.mount();
+		const headers = options.headers || Object.create(null);
+		if (this.http && this.http instanceof Http) {
+			if (options.cookie) for (const key in options.cookie) this.http.cookie.write(key, options.cookie[key]);
+			if (options.session) {
+				for (const key in options.session) this.http.session.write(key, options.session[key]);
+				this.http.session.update();
+			}
+			const cookie = this.http.cookie.headers()["Set-Cookie"]?.map((c) => c.split(";")[0]).join(";");
+			if (cookie) if (headers.cookie) headers.cookie += `;${cookie}`;
+			else headers.cookie = cookie;
+		}
+		const response = await this._handler({
+			httpMethod: "POST",
+			headers: Object.assign({ "content-type": "application/json" }, headers),
+			body: typeof body === "string" ? body : JSON.stringify(body)
+		});
+		if (response?.body instanceof ReadableStream) {
+			let stream = response.body;
+			const encoding = response.headers?.["Content-Encoding"] || response.headers?.["content-encoding"];
+			if (encoding) {
+				const chunks = [];
+				const reader = stream.getReader();
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						if (value) chunks.push(value);
+					}
+				} catch (error) {
+					this.logger.error("Failed to read ReadableStream: %s", error);
+					response.body = JSON.stringify({ error: { message: error.message } });
+					response.error = { message: error.message };
+					response.statusCode = 500;
+					reader.releaseLock();
+					return response;
+				}
+				reader.releaseLock();
+				const compressedBuffer = Buffer.concat(chunks);
+				try {
+					let decompressed;
+					if (encoding === "br") decompressed = brotliDecompressSync(compressedBuffer);
+					else if (encoding === "gzip") decompressed = gunzipSync(compressedBuffer);
+					else if (encoding === "deflate") decompressed = inflateSync(compressedBuffer);
+					else throw new Error(`Unsupported encoding: ${encoding}`);
+					stream = new ReadableStream({ start(controller) {
+						controller.enqueue(new Uint8Array(decompressed));
+						controller.close();
+					} });
+				} catch (error) {
+					this.logger.error("Failed to decompress: %s", error);
+					response.body = JSON.stringify({ error: { message: error.message } });
+					response.error = { message: error.message };
+					response.statusCode = 500;
+					return response;
+				}
+			}
+			try {
+				response.body = await streamToText(stream);
+			} catch (error) {
+				this.logger.error("Failed to decode ReadableStream: %s", error);
+				response.body = JSON.stringify({ error: { message: error.message } });
+				response.error = { message: error.message };
+				response.statusCode = 500;
+			}
+		}
+		if (response?.headers && response.body && response.headers["content-type"]?.includes("json")) {
+			const parsedBody = JSON.parse(response.body);
+			response.data = parsedBody.data;
+			response.error = parsedBody.error;
+		}
+		if (this.http) {
+			response.cookie = this.http.cookie.content;
+			response.session = this.http.session.content;
+		}
+		this.logger.debug("response: %j", response);
+		return response;
+	}
+};
+/**
+* A simple way to wrap a FaasJS function.
+* @param initBy {Func} Full file path or a FaasJs function
+*
+* ```ts
+* import { test } from '@faasjs/dev'
+* import Func from '../demo.func.ts'
+*
+* const func = test(Func)
+*
+* expect(await func.handler()).toEqual('Hello, world')
+* ```
+*/
+function test(initBy) {
+	const warper = new FuncWarper(initBy);
+	warper.mount = warper.mount.bind(warper);
+	warper.handler = warper.handler.bind(warper);
+	warper.JSONhandler = warper.JSONhandler.bind(warper);
+	return warper;
+}
+
+//#endregion
+//#region src/vite.ts
+const TYPEGEN_DEBOUNCE = 120;
+function normalizeBase(base) {
+	const normalized = base.startsWith("/") ? base : `/${base}`;
+	if (normalized === "/") return "/";
+	return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function stripBase(url, base) {
+	if (base === "/") return url;
+	const queryIndex = url.indexOf("?");
+	const pathname = queryIndex >= 0 ? url.slice(0, queryIndex) : url;
+	const search = queryIndex >= 0 ? url.slice(queryIndex) : "";
+	if (pathname === base) return `/${search}`;
+	if (pathname.startsWith(`${base}/`)) return `${pathname.slice(base.length)}${search}`;
+	return url;
+}
+/**
+* Create a Vite plugin that proxies POST requests to an in-process FaasJS server.
+*
+* It resolves server root/base from `src/faas.yaml` and strips `base` from
+* request URL before forwarding to `@faasjs/core`.
+*/
+function viteFaasJsServer() {
+	let config;
+	let server = null;
+	const logger = new Logger("FaasJs:Vite");
+	return {
+		name: "vite:faasjs",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			const { root, base } = resolveServerConfig(resolvedConfig.root, logger, resolvedConfig.base);
+			config = {
+				root,
+				base: normalizeBase(base)
+			};
+		},
+		configureServer: async ({ middlewares, watcher }) => {
+			if (process.env.VITEST) {
+				logger.debug("Skipping faas server in vitest environment");
+				return;
+			}
+			if (!config) throw new Error("viteFaasJsServer: config is not resolved");
+			server = new Server(join(config.root, "src"));
+			const runTypegen = async () => {
+				try {
+					const result = await generateFaasTypes({ root: config.root });
+					logger.debug("[faas types] %s %s (%i routes)", result.changed ? "generated" : "up-to-date", result.output, result.routeCount);
+				} catch (error) {
+					logger.error("[faas types] %s", error.message);
+				}
+			};
+			let timer;
+			let typegenChain = Promise.resolve();
+			const scheduleTypegen = () => {
+				if (timer) clearTimeout(timer);
+				timer = setTimeout(() => {
+					typegenChain = typegenChain.then(runTypegen);
+				}, TYPEGEN_DEBOUNCE);
+			};
+			await runTypegen();
+			watcher.on("all", (_eventName, filePath) => {
+				if (!isTypegenSourceFile(filePath)) return;
+				scheduleTypegen();
+			});
+			middlewares.use(async (req, res, next) => {
+				if (!req.url || req.method !== "POST" || !server) return next();
+				const originalUrl = req.url;
+				req.url = stripBase(req.url, config.base);
+				try {
+					logger.debug(`Request ${req.url}`);
+					await server.handle(req, res, { requestedAt: Date.now() });
+				} catch (error) {
+					logger.error(error);
+					if (!res.headersSent && !res.writableEnded) {
+						res.writeHead(500, { "Content-Type": "application/json" });
+						res.write(JSON.stringify({ error: { message: "Internal Server Error" } }));
+						res.end();
+					}
+				} finally {
+					req.url = originalUrl;
+				}
+				if (!res.writableEnded) next();
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	FuncWarper: () => FuncWarper,
+	generateFaasTypes: () => generateFaasTypes,
+	isTypegenSourceFile: () => isTypegenSourceFile,
+	streamToObject: () => streamToObject,
+	streamToString: () => streamToString,
+	streamToText: () => streamToText,
+	test: () => test,
+	viteFaasJsServer: () => viteFaasJsServer
+});
+
+//#endregion
+export { FuncWarper, generateFaasTypes, isTypegenSourceFile, streamToObject, streamToString, streamToText, test, viteFaasJsServer };

package/dist/typegen-BNWmP5Qp.mjs

@@ -0,0 +1,165 @@
+import { Logger, loadConfig } from "@faasjs/node-utils";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+
+//#region src/server_config.ts
+function resolveFaasStaging() {
+	return process.env.FaasEnv || "development";
+}
+function resolveServerConfig(root, logger, defaultBase = "/") {
+	const projectRoot = resolve(root);
+	const staging = resolveFaasStaging();
+	const srcRoot = join(projectRoot, "src");
+	const config = loadConfig(srcRoot, join(srcRoot, "index.func.ts"), staging, logger);
+	const server = config && typeof config === "object" ? config.server : void 0;
+	return {
+		root: typeof server?.root === "string" && server.root.length ? resolve(projectRoot, server.root) : projectRoot,
+		base: typeof server?.base === "string" && server.base.length ? server.base : defaultBase,
+		staging
+	};
+}
+
+//#endregion
+//#region src/typegen.ts
+function normalizeRoute(path) {
+	const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
+	if (!normalized.length || normalized === "/") return "/";
+	return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function toTypegenRoute(route) {
+	return route === "/" ? "/" : route.replace(/^\/+/, "");
+}
+function toRoute(srcRoot, file) {
+	const noTsPath = relative(srcRoot, file).replace(/\\/g, "/").replace(/\.ts$/, "");
+	if (noTsPath === "index.func") return {
+		route: "/",
+		priority: 2
+	};
+	if (noTsPath === "default.func") return {
+		route: "/*",
+		priority: 1
+	};
+	if (noTsPath.endsWith("/index.func")) return {
+		route: normalizeRoute(`/${noTsPath.slice(0, -11)}`),
+		priority: 2
+	};
+	if (noTsPath.endsWith("/default.func")) return {
+		route: normalizeRoute(`/${noTsPath.slice(0, -13)}/*`),
+		priority: 1
+	};
+	if (noTsPath.endsWith(".func")) return {
+		route: normalizeRoute(`/${noTsPath.slice(0, -5)}`),
+		priority: 3
+	};
+	throw Error(`[faas types] Invalid func filename: ${file}`);
+}
+function toImportPath(fromFile, targetFile) {
+	const importPath = relative(dirname(fromFile), targetFile).replace(/\\/g, "/").replace(/\.ts$/, "");
+	if (importPath.startsWith(".")) return importPath;
+	return `./${importPath}`;
+}
+function parsePluginTypes(config) {
+	const pluginConfig = config.plugins;
+	if (!pluginConfig || typeof pluginConfig !== "object") return [];
+	const pluginTypes = /* @__PURE__ */ new Set();
+	for (const key in pluginConfig) {
+		const data = pluginConfig[key];
+		if (typeof data === "string" && data.length) {
+			pluginTypes.add(data);
+			continue;
+		}
+		if (data && typeof data === "object") {
+			if (typeof data.type === "string" && data.type.length) pluginTypes.add(data.type);
+			else pluginTypes.add(key);
+			continue;
+		}
+		pluginTypes.add(key);
+	}
+	return Array.from(pluginTypes).sort((a, b) => a.localeCompare(b));
+}
+async function readFuncFiles(dir) {
+	const result = [];
+	const pendingDirs = [dir];
+	while (pendingDirs.length) {
+		const currentDir = pendingDirs.pop();
+		const entries = await readdir(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name === ".faasjs" || entry.name === "node_modules") continue;
+			const filePath = join(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				pendingDirs.push(filePath);
+				continue;
+			}
+			if (entry.isFile() && entry.name.endsWith(".func.ts")) result.push(filePath);
+		}
+	}
+	return result.sort((a, b) => a.localeCompare(b));
+}
+function formatTypes(items) {
+	const actionLines = items.map((item) => {
+		return `    ${JSON.stringify(toTypegenRoute(item.route))}: InferFaasAction<InferFaasFunc<typeof import(${JSON.stringify(item.importPath)})>>`;
+	});
+	const eventLines = items.map((item) => {
+		const plugins = item.pluginTypes.length ? `[${item.pluginTypes.map((type) => JSON.stringify(type)).join(", ")}]` : "[]";
+		return `    ${JSON.stringify(toTypegenRoute(item.route))}: InferPluginEvent<${plugins}>`;
+	});
+	return `/**
+ * Generated by @faasjs/dev.
+ *
+ * Do not edit this file manually.
+ */
+import type { Func, InferPluginEvent } from '@faasjs/core'
+import type { InferFaasAction, InferFaasFunc } from '@faasjs/types'
+
+declare module '@faasjs/types' {
+  interface FaasActions {
+${actionLines.length ? `${actionLines.join("\n")}\n` : ""}  }
+
+  interface FaasEvents {
+${eventLines.length ? `${eventLines.join("\n")}\n` : ""}  }
+}
+`;
+}
+function isTypegenSourceFile(filePath) {
+	return filePath.endsWith(".func.ts") || /(^|[\\/])faas\.ya?ml$/.test(filePath);
+}
+async function generateFaasTypes(options = {}) {
+	const logger = options.logger ?? new Logger("FaasJs:Typegen");
+	const { root: projectRoot, staging } = resolveServerConfig(options.root ?? process.cwd(), logger);
+	const srcRoot = join(projectRoot, "src");
+	const output = join(srcRoot, ".faasjs", "types.d.ts");
+	if (!existsSync(srcRoot)) throw Error(`[faas types] Source directory not found: ${srcRoot}`);
+	const files = await readFuncFiles(srcRoot);
+	const routeMap = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const { route, priority } = toRoute(srcRoot, file);
+		const prev = routeMap.get(route);
+		if (prev && priority <= prev.priority) continue;
+		routeMap.set(route, {
+			route,
+			importPath: toImportPath(output, file),
+			pluginTypes: parsePluginTypes(loadConfig(srcRoot, file, staging, logger)),
+			priority
+		});
+	}
+	const items = Array.from(routeMap.values()).sort((a, b) => a.route.localeCompare(b.route));
+	const content = formatTypes(items);
+	let changed = true;
+	try {
+		if (await readFile(output, "utf8") === content) changed = false;
+	} catch {}
+	if (changed) {
+		await mkdir(dirname(output), { recursive: true });
+		await writeFile(output, content);
+	}
+	return {
+		output,
+		changed,
+		fileCount: files.length,
+		routeCount: items.length
+	};
+}
+
+//#endregion
+export { isTypegenSourceFile as n, resolveServerConfig as r, generateFaasTypes as t };

package/dist/typegen-HX5QyuhP.cjs

@@ -0,0 +1,182 @@
+let _faasjs_node_utils = require("@faasjs/node-utils");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+
+//#region src/server_config.ts
+function resolveFaasStaging() {
+	return process.env.FaasEnv || "development";
+}
+function resolveServerConfig(root, logger, defaultBase = "/") {
+	const projectRoot = (0, node_path.resolve)(root);
+	const staging = resolveFaasStaging();
+	const srcRoot = (0, node_path.join)(projectRoot, "src");
+	const config = (0, _faasjs_node_utils.loadConfig)(srcRoot, (0, node_path.join)(srcRoot, "index.func.ts"), staging, logger);
+	const server = config && typeof config === "object" ? config.server : void 0;
+	return {
+		root: typeof server?.root === "string" && server.root.length ? (0, node_path.resolve)(projectRoot, server.root) : projectRoot,
+		base: typeof server?.base === "string" && server.base.length ? server.base : defaultBase,
+		staging
+	};
+}
+
+//#endregion
+//#region src/typegen.ts
+function normalizeRoute(path) {
+	const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
+	if (!normalized.length || normalized === "/") return "/";
+	return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function toTypegenRoute(route) {
+	return route === "/" ? "/" : route.replace(/^\/+/, "");
+}
+function toRoute(srcRoot, file) {
+	const noTsPath = (0, node_path.relative)(srcRoot, file).replace(/\\/g, "/").replace(/\.ts$/, "");
+	if (noTsPath === "index.func") return {
+		route: "/",
+		priority: 2
+	};
+	if (noTsPath === "default.func") return {
+		route: "/*",
+		priority: 1
+	};
+	if (noTsPath.endsWith("/index.func")) return {
+		route: normalizeRoute(`/${noTsPath.slice(0, -11)}`),
+		priority: 2
+	};
+	if (noTsPath.endsWith("/default.func")) return {
+		route: normalizeRoute(`/${noTsPath.slice(0, -13)}/*`),
+		priority: 1
+	};
+	if (noTsPath.endsWith(".func")) return {
+		route: normalizeRoute(`/${noTsPath.slice(0, -5)}`),
+		priority: 3
+	};
+	throw Error(`[faas types] Invalid func filename: ${file}`);
+}
+function toImportPath(fromFile, targetFile) {
+	const importPath = (0, node_path.relative)((0, node_path.dirname)(fromFile), targetFile).replace(/\\/g, "/").replace(/\.ts$/, "");
+	if (importPath.startsWith(".")) return importPath;
+	return `./${importPath}`;
+}
+function parsePluginTypes(config) {
+	const pluginConfig = config.plugins;
+	if (!pluginConfig || typeof pluginConfig !== "object") return [];
+	const pluginTypes = /* @__PURE__ */ new Set();
+	for (const key in pluginConfig) {
+		const data = pluginConfig[key];
+		if (typeof data === "string" && data.length) {
+			pluginTypes.add(data);
+			continue;
+		}
+		if (data && typeof data === "object") {
+			if (typeof data.type === "string" && data.type.length) pluginTypes.add(data.type);
+			else pluginTypes.add(key);
+			continue;
+		}
+		pluginTypes.add(key);
+	}
+	return Array.from(pluginTypes).sort((a, b) => a.localeCompare(b));
+}
+async function readFuncFiles(dir) {
+	const result = [];
+	const pendingDirs = [dir];
+	while (pendingDirs.length) {
+		const currentDir = pendingDirs.pop();
+		const entries = await (0, node_fs_promises.readdir)(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name === ".faasjs" || entry.name === "node_modules") continue;
+			const filePath = (0, node_path.join)(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				pendingDirs.push(filePath);
+				continue;
+			}
+			if (entry.isFile() && entry.name.endsWith(".func.ts")) result.push(filePath);
+		}
+	}
+	return result.sort((a, b) => a.localeCompare(b));
+}
+function formatTypes(items) {
+	const actionLines = items.map((item) => {
+		return `    ${JSON.stringify(toTypegenRoute(item.route))}: InferFaasAction<InferFaasFunc<typeof import(${JSON.stringify(item.importPath)})>>`;
+	});
+	const eventLines = items.map((item) => {
+		const plugins = item.pluginTypes.length ? `[${item.pluginTypes.map((type) => JSON.stringify(type)).join(", ")}]` : "[]";
+		return `    ${JSON.stringify(toTypegenRoute(item.route))}: InferPluginEvent<${plugins}>`;
+	});
+	return `/**
+ * Generated by @faasjs/dev.
+ *
+ * Do not edit this file manually.
+ */
+import type { Func, InferPluginEvent } from '@faasjs/core'
+import type { InferFaasAction, InferFaasFunc } from '@faasjs/types'
+
+declare module '@faasjs/types' {
+  interface FaasActions {
+${actionLines.length ? `${actionLines.join("\n")}\n` : ""}  }
+
+  interface FaasEvents {
+${eventLines.length ? `${eventLines.join("\n")}\n` : ""}  }
+}
+`;
+}
+function isTypegenSourceFile(filePath) {
+	return filePath.endsWith(".func.ts") || /(^|[\\/])faas\.ya?ml$/.test(filePath);
+}
+async function generateFaasTypes(options = {}) {
+	const logger = options.logger ?? new _faasjs_node_utils.Logger("FaasJs:Typegen");
+	const { root: projectRoot, staging } = resolveServerConfig(options.root ?? process.cwd(), logger);
+	const srcRoot = (0, node_path.join)(projectRoot, "src");
+	const output = (0, node_path.join)(srcRoot, ".faasjs", "types.d.ts");
+	if (!(0, node_fs.existsSync)(srcRoot)) throw Error(`[faas types] Source directory not found: ${srcRoot}`);
+	const files = await readFuncFiles(srcRoot);
+	const routeMap = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const { route, priority } = toRoute(srcRoot, file);
+		const prev = routeMap.get(route);
+		if (prev && priority <= prev.priority) continue;
+		routeMap.set(route, {
+			route,
+			importPath: toImportPath(output, file),
+			pluginTypes: parsePluginTypes((0, _faasjs_node_utils.loadConfig)(srcRoot, file, staging, logger)),
+			priority
+		});
+	}
+	const items = Array.from(routeMap.values()).sort((a, b) => a.route.localeCompare(b.route));
+	const content = formatTypes(items);
+	let changed = true;
+	try {
+		if (await (0, node_fs_promises.readFile)(output, "utf8") === content) changed = false;
+	} catch {}
+	if (changed) {
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(output), { recursive: true });
+		await (0, node_fs_promises.writeFile)(output, content);
+	}
+	return {
+		output,
+		changed,
+		fileCount: files.length,
+		routeCount: items.length
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'generateFaasTypes', {
+  enumerable: true,
+  get: function () {
+    return generateFaasTypes;
+  }
+});
+Object.defineProperty(exports, 'isTypegenSourceFile', {
+  enumerable: true,
+  get: function () {
+    return isTypegenSourceFile;
+  }
+});
+Object.defineProperty(exports, 'resolveServerConfig', {
+  enumerable: true,
+  get: function () {
+    return resolveServerConfig;
+  }
+});

package/faas.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+import { main } from './dist/cli/index.mjs'
+
+main(process.argv).then((code) => {
+  if (code !== 0) process.exit(code)
+})

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@faasjs/dev",
+  "version": "8.0.0-beta.10",
+  "homepage": "https://faasjs.com/doc/dev",
+  "bugs": {
+    "url": "https://github.com/faasjs/faasjs/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/faasjs/faasjs.git",
+    "directory": "packages/dev"
+  },
+  "funding": "https://github.com/sponsors/faasjs",
+  "bin": {
+    "faas": "faas.mjs"
+  },
+  "files": [
+    "dist",
+    "faas.mjs",
+    "configs"
+  ],
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsdown --entry src/index.ts --entry src/cli/index.ts --config ../../tsdown.config.ts"
+  },
+  "devDependencies": {
+    "@faasjs/core": ">=8.0.0-beta.10",
+    "@faasjs/node-utils": ">=8.0.0-beta.10",
+    "@types/node": "*",
+    "knex": "*",
+    "oxlint": "*",
+    "vite": "*",
+    "vitest": "*"
+  },
+  "peerDependencies": {
+    "@faasjs/core": ">=8.0.0-beta.10",
+    "@faasjs/node-utils": ">=8.0.0-beta.10",
+    "@types/node": "*",
+    "knex": "*",
+    "oxlint": "*",
+    "vite": "*",
+    "vitest": "*"
+  },
+  "engines": {
+    "node": ">=24.0.0",
+    "npm": ">=11.0.0"
+  }
+}