@ubean/preset 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,342 @@
+//#region src/capabilities.d.ts
+type RuntimeTarget = 'node' | 'worker' | 'browser' | 'deno' | 'bun' | 'edge-light';
+interface CapabilitySet {
+  staticServe: boolean;
+  websocket: boolean;
+  sse: boolean;
+  cronTriggers: boolean;
+  queues: boolean;
+  kv: boolean;
+  storage: boolean;
+  database: boolean;
+  envVars: boolean;
+  secrets: boolean;
+  nodeCompat: boolean;
+  streaming: boolean;
+  compression: boolean;
+  https: boolean;
+  http2: boolean;
+  middleware: boolean;
+  bodyLimit: boolean;
+  multipart: boolean;
+  rpc: boolean;
+}
+interface CapabilityInfo extends CapabilitySet {
+  runtime: RuntimeTarget[];
+}
+type CapabilityName = keyof CapabilitySet;
+interface CapabilityRequirement {
+  capability: CapabilityName;
+  required: boolean;
+  message?: string;
+}
+interface CapabilityDiagnostic {
+  capability: CapabilityName;
+  supported: boolean;
+  required: boolean;
+  message: string;
+}
+interface CapabilityDiagnosisResult {
+  valid: boolean;
+  diagnostics: CapabilityDiagnostic[];
+  errors: string[];
+  warnings: string[];
+  presetName: string;
+}
+declare function createCapabilitySet(overrides?: Partial<CapabilitySet>): CapabilitySet;
+declare function diagnoseCapabilities(presetName: string, presetCapabilities: Partial<CapabilitySet>, requirements: CapabilityRequirement[]): CapabilityDiagnosisResult;
+declare function requireCapability(capability: CapabilityName, required?: boolean, message?: string): CapabilityRequirement;
+declare const NODE_CAPABILITIES: CapabilitySet;
+declare const STANDARD_CAPABILITIES: CapabilitySet;
+declare const WORKER_CAPABILITIES: CapabilitySet;
+declare const DEV_REQUIREMENTS: CapabilityRequirement[];
+declare const NODE_REQUIREMENTS: CapabilityRequirement[];
+//#endregion
+//#region src/registry.d.ts
+type PresetHooks = {
+  'build:before'?: (ctx: PresetBuildContext) => void | Promise<void>;
+  'build:after'?: (ctx: PresetBuildContext) => void | Promise<void>;
+  compiled?: (ctx: PresetBuildContext) => void | Promise<void>;
+  'dev:setup'?: (ctx: PresetDevContext) => void | Promise<void>;
+};
+interface PresetBuildContext {
+  cwd: string;
+  outputDir: string;
+  preset: ResolvedPreset;
+  config: Record<string, unknown>;
+}
+interface PresetDevContext {
+  cwd: string;
+  preset: ResolvedPreset;
+  config: Record<string, unknown>;
+}
+interface PresetOutputConfig {
+  dir?: string;
+  serverDir?: string;
+  publicDir?: string;
+}
+interface PresetRollupConfig {
+  plugins?: unknown[];
+  output?: Record<string, unknown>;
+  external?: string[];
+}
+interface PresetMeta {
+  name: string;
+  aliases?: string[];
+  stdName?: string;
+  static?: boolean;
+  dev?: boolean;
+  compatibilityDate?: string;
+  url?: string;
+}
+interface PresetRuntimeConfig {
+  entry?: string;
+  handler?: string;
+  compatibilityDate?: string;
+  compatibilityFlags?: string[];
+  [key: string]: unknown;
+}
+interface PresetDefinition {
+  name?: string;
+  extends?: string;
+  entry?: string;
+  exportConditions?: string[];
+  serve?: {
+    host?: string;
+    port?: number;
+  };
+  build?: {
+    outputDir?: string;
+    format?: 'esm' | 'cjs';
+    externals?: string[];
+    minify?: boolean;
+    rollupConfig?: PresetRollupConfig;
+  };
+  output?: PresetOutputConfig;
+  runtime?: PresetRuntimeConfig;
+  devServer?: {
+    runner?: string;
+  };
+  capabilities?: Partial<CapabilitySet>;
+  capabilityInfo?: Partial<CapabilityInfo>;
+  hooks?: PresetHooks;
+  alias?: Record<string, string>;
+  wasm?: {
+    lazy?: boolean;
+    esmImport?: boolean;
+  };
+  unenv?: unknown[];
+  commands?: {
+    preview?: string;
+    deploy?: string;
+  };
+  nitro?: Record<string, unknown>;
+}
+type Preset = PresetDefinition | (() => PresetDefinition);
+interface ResolvedPreset extends PresetDefinition {
+  name: string;
+  _meta: PresetMeta;
+}
+declare function definePreset<P extends PresetDefinition>(preset: P, meta?: PresetMeta): P & {
+  _meta: PresetMeta;
+  name: string;
+};
+declare function resolvePreset(name: string): ResolvedPreset | undefined;
+declare function getRegisteredPresets(): Array<PresetDefinition & {
+  _meta: PresetMeta;
+}>;
+declare function registerPreset(preset: Preset, meta?: PresetMeta): void;
+declare function getPresetNames(): string[];
+declare function getPresetAliases(): Map<string, string>;
+//#endregion
+//#region src/cloudflare.d.ts
+declare const cloudflarePreset: {
+  capabilities: CapabilitySet;
+  entry: string;
+  exportConditions: string[];
+  build: {
+    outputDir: string;
+    format: "esm";
+    minify: false;
+    externals: string[];
+    rollupConfig: {
+      external: string[];
+    };
+  };
+  output: {
+    dir: string;
+    serverDir: string;
+    publicDir: string;
+  };
+  runtime: {
+    entry: string;
+    handler: string;
+    compatibilityDate: string;
+    compatibilityFlags: string[];
+  };
+  wasm: {
+    lazy: false;
+    esmImport: true;
+  };
+  serve: {
+    host: string;
+    port: number;
+  };
+  commands: {
+    preview: string;
+    deploy: string;
+  };
+  hooks: {
+    'build:before': () => Promise<void>;
+    compiled: () => Promise<void>;
+  };
+} & {
+  _meta: PresetMeta;
+  name: string;
+};
+declare const cloudflareDevPreset: {
+  extends: string;
+  devServer: {
+    runner: string;
+  };
+} & {
+  _meta: PresetMeta;
+  name: string;
+};
+interface WranglerConfig {
+  name?: string;
+  main?: string;
+  compatibility_date?: string;
+  compatibility_flags?: string[];
+  workers_dev?: boolean;
+  routes?: string[];
+  kv_namespaces?: Array<{
+    binding: string;
+    id?: string;
+    preview_id?: string;
+  }>;
+  vars?: Record<string, string>;
+  secrets?: string[];
+  queues?: {
+    producers?: Array<{
+      binding: string;
+      queue: string;
+    }>;
+    consumers?: Array<{
+      queue: string;
+    }>;
+  };
+  d1_databases?: Array<{
+    binding: string;
+    database_id?: string;
+    preview_database_id?: string;
+  }>;
+  r2_buckets?: Array<{
+    binding: string;
+    bucket_name?: string;
+    preview_bucket_name?: string;
+  }>;
+  observability?: {
+    enabled: boolean;
+  };
+  assets?: {
+    directory?: string;
+    binding?: string;
+  };
+}
+declare function generateWranglerConfig(options: {
+  name: string;
+  entry?: string;
+  compatibilityDate?: string;
+  compatibilityFlags?: string[];
+  kvNamespaces?: Array<{
+    binding: string;
+    id?: string;
+  }>;
+  vars?: Record<string, string>;
+  d1Databases?: Array<{
+    binding: string;
+    databaseId?: string;
+  }>;
+  r2Buckets?: Array<{
+    binding: string;
+    bucketName?: string;
+  }>;
+  queuesProducers?: Array<{
+    binding: string;
+    queue: string;
+  }>;
+  queuesConsumers?: Array<{
+    queue: string;
+  }>;
+  assetsDir?: string;
+  observability?: boolean;
+}): WranglerConfig;
+declare function serializeWranglerToml(config: WranglerConfig): string;
+//#endregion
+//#region src/node.d.ts
+declare const nodePreset: {
+  extends: string;
+  capabilities: CapabilitySet;
+  build: {
+    outputDir: string;
+    format: "esm";
+    externals: string[];
+  };
+  runtime: {
+    entry: string;
+    handler: string;
+  };
+  serve: {
+    host: string;
+    port: number;
+  };
+  commands: {
+    preview: string;
+  };
+} & {
+  _meta: PresetMeta;
+  name: string;
+};
+//#endregion
+//#region src/standard.d.ts
+declare const standardPreset: {
+  capabilities: CapabilitySet;
+  build: {
+    outputDir: string;
+    format: "esm";
+    externals: string[];
+  };
+  runtime: {
+    entry: string;
+  };
+  serve: {
+    host: string;
+    port: number;
+  };
+} & {
+  _meta: PresetMeta;
+  name: string;
+};
+//#endregion
+//#region src/detect.d.ts
+interface PresetDetectionHints {
+  cwd?: string;
+  explicitPreset?: string;
+  environment?: Record<string, string | undefined>;
+  globalThis?: Record<string, unknown>;
+}
+interface PresetDetectionResult {
+  preset: ResolvedPreset;
+  source: 'explicit' | 'config-file' | 'environment' | 'default';
+  reason?: string;
+}
+declare function detectPreset(hints?: PresetDetectionHints): PresetDetectionResult;
+declare function resolvePresetWithDetection(explicitPreset?: string, cwd?: string): PresetDetectionResult;
+declare function listDetectablePresets(): PresetDefinition[];
+//#endregion
+//#region src/index.d.ts
+declare function registerBuiltinPresets(): void;
+declare function resolvePresetByName(name: string): ResolvedPreset;
+//#endregion
+export { CapabilityDiagnosisResult, CapabilityDiagnostic, CapabilityInfo, CapabilityName, CapabilityRequirement, CapabilitySet, DEV_REQUIREMENTS, NODE_CAPABILITIES, NODE_REQUIREMENTS, type Preset, type PresetBuildContext, type PresetDefinition, type PresetDetectionHints, type PresetDetectionResult, type PresetDevContext, type PresetHooks, type PresetMeta, type ResolvedPreset, RuntimeTarget, STANDARD_CAPABILITIES, WORKER_CAPABILITIES, type WranglerConfig, cloudflareDevPreset, cloudflarePreset, createCapabilitySet, definePreset, detectPreset, diagnoseCapabilities, generateWranglerConfig, getPresetAliases, getPresetNames, getRegisteredPresets, listDetectablePresets, nodePreset, registerBuiltinPresets, registerPreset, requireCapability, resolvePreset, resolvePresetByName, resolvePresetWithDetection, serializeWranglerToml, standardPreset };

package/dist/index.js

@@ -0,0 +1,650 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/capabilities.ts
+const DEFAULT_CAPABILITIES = {
+	staticServe: false,
+	websocket: false,
+	sse: false,
+	cronTriggers: false,
+	queues: false,
+	kv: false,
+	storage: false,
+	database: false,
+	envVars: true,
+	secrets: false,
+	nodeCompat: false,
+	streaming: true,
+	compression: false,
+	https: false,
+	http2: false,
+	middleware: true,
+	bodyLimit: true,
+	multipart: false,
+	rpc: false
+};
+function createCapabilitySet(overrides = {}) {
+	return {
+		...DEFAULT_CAPABILITIES,
+		...overrides
+	};
+}
+const CAPABILITY_MESSAGES = {
+	staticServe: { missing: "Preset does not support static file serving" },
+	websocket: { missing: "Preset does not support WebSocket" },
+	sse: { missing: "Preset does not support Server-Sent Events" },
+	cronTriggers: { missing: "Preset does not support cron triggers" },
+	queues: { missing: "Preset does not support queue processing" },
+	kv: { missing: "Preset does not support KV storage" },
+	storage: { missing: "Preset does not support blob storage" },
+	database: { missing: "Preset does not have built-in database support" },
+	envVars: { missing: "Preset does not support environment variables" },
+	secrets: { missing: "Preset does not support secret management" },
+	nodeCompat: { missing: "Preset does not provide Node.js compatibility layer" },
+	streaming: { missing: "Preset does not support streaming responses" },
+	compression: { missing: "Preset does not support response compression" },
+	https: { missing: "Preset does not support HTTPS" },
+	http2: { missing: "Preset does not support HTTP/2" },
+	middleware: { missing: "Preset does not support middleware" },
+	bodyLimit: { missing: "Preset does not support request body size limits" },
+	multipart: { missing: "Preset does not support multipart/form-data" },
+	rpc: { missing: "Preset does not support RPC transport" }
+};
+function diagnoseCapabilities(presetName, presetCapabilities, requirements) {
+	const capabilities = createCapabilitySet(presetCapabilities);
+	const diagnostics = [];
+	const errors = [];
+	const warnings = [];
+	for (const req of requirements) {
+		const supported = capabilities[req.capability];
+		const messages = CAPABILITY_MESSAGES[req.capability];
+		const message = req.message || messages.missing;
+		diagnostics.push({
+			capability: req.capability,
+			supported,
+			required: req.required,
+			message: supported ? `${req.capability} is supported` : message
+		});
+		if (!supported) if (req.required) errors.push(`[${presetName}] ${message}`);
+		else warnings.push(`[${presetName}] ${message}`);
+	}
+	return {
+		valid: errors.length === 0,
+		diagnostics,
+		errors,
+		warnings,
+		presetName
+	};
+}
+function requireCapability(capability, required = true, message) {
+	return {
+		capability,
+		required,
+		message
+	};
+}
+const NODE_CAPABILITIES = createCapabilitySet({
+	staticServe: true,
+	websocket: true,
+	sse: true,
+	cronTriggers: true,
+	queues: true,
+	kv: true,
+	storage: true,
+	database: true,
+	secrets: true,
+	nodeCompat: true,
+	streaming: true,
+	compression: true,
+	https: true,
+	http2: true,
+	multipart: true,
+	rpc: true
+});
+const STANDARD_CAPABILITIES = createCapabilitySet({
+	staticServe: true,
+	sse: true,
+	middleware: true,
+	bodyLimit: true,
+	streaming: true
+});
+const WORKER_CAPABILITIES = createCapabilitySet({
+	staticServe: true,
+	websocket: true,
+	sse: true,
+	kv: true,
+	storage: false,
+	envVars: true,
+	nodeCompat: false,
+	streaming: true,
+	middleware: true,
+	bodyLimit: true
+});
+const DEV_REQUIREMENTS = [
+	requireCapability("middleware", true, "Dev server requires middleware support"),
+	requireCapability("streaming", true, "Dev server requires streaming support for SSE/HMR"),
+	requireCapability("envVars", true, "Dev server requires environment variable support"),
+	requireCapability("staticServe", false, "Static file serving is recommended for dev"),
+	requireCapability("nodeCompat", false, "Node compatibility enables full dev feature set")
+];
+const NODE_REQUIREMENTS = DEV_REQUIREMENTS;
+//#endregion
+//#region src/registry.ts
+const presets = /* @__PURE__ */ new Map();
+const presetNames = /* @__PURE__ */ new Map();
+function definePreset(preset, meta) {
+	const name = meta?.name || preset.name || "unknown";
+	const finalMeta = {
+		name,
+		aliases: [],
+		static: false,
+		dev: false,
+		...meta
+	};
+	const presetWithMeta = {
+		...preset,
+		name,
+		_meta: finalMeta
+	};
+	presets.set(name, presetWithMeta);
+	presetNames.set(name, name);
+	if (finalMeta.aliases) for (const alias of finalMeta.aliases) presetNames.set(alias, name);
+	return presetWithMeta;
+}
+function resolvePresetDefinition(preset) {
+	return typeof preset === "function" ? preset() : preset;
+}
+function resolvePreset(name) {
+	const resolvedName = presetNames.get(name);
+	if (!resolvedName) return void 0;
+	if (!presets.get(resolvedName)) return void 0;
+	return resolvePresetWithInheritance(resolvedName, /* @__PURE__ */ new Set());
+}
+function resolvePresetWithInheritance(name, visited) {
+	if (visited.has(name)) throw new Error(`Circular preset inheritance detected: ${[...visited, name].join(" -> ")}`);
+	visited.add(name);
+	const preset = presets.get(name);
+	if (!preset) return void 0;
+	let base = { name };
+	if (preset.extends) {
+		const parent = resolvePresetWithInheritance(preset.extends, visited);
+		if (parent) base = mergePreset(parent, {});
+	}
+	const resolved = mergePreset(base, preset);
+	resolved.name = name;
+	resolved._meta = preset._meta;
+	return resolved;
+}
+function mergePreset(base, override) {
+	return {
+		name: override.name ?? base.name,
+		extends: override.extends ?? base.extends,
+		entry: override.entry ?? base.entry,
+		exportConditions: override.exportConditions ?? base.exportConditions,
+		serve: {
+			...base.serve,
+			...override.serve
+		},
+		build: {
+			...base.build,
+			...override.build
+		},
+		output: {
+			...base.output,
+			...override.output
+		},
+		runtime: {
+			...base.runtime,
+			...override.runtime
+		},
+		devServer: {
+			...base.devServer,
+			...override.devServer
+		},
+		capabilities: {
+			...base.capabilities,
+			...override.capabilities
+		},
+		capabilityInfo: {
+			...base.capabilityInfo,
+			...override.capabilityInfo
+		},
+		hooks: {
+			...base.hooks,
+			...override.hooks
+		},
+		alias: {
+			...base.alias,
+			...override.alias
+		},
+		wasm: {
+			...base.wasm,
+			...override.wasm
+		},
+		unenv: [...base.unenv || [], ...override.unenv || []],
+		commands: {
+			...base.commands,
+			...override.commands
+		},
+		nitro: {
+			...base.nitro,
+			...override.nitro
+		}
+	};
+}
+function getRegisteredPresets() {
+	return [...presets.values()];
+}
+function registerPreset(preset, meta) {
+	definePreset(resolvePresetDefinition(preset), meta);
+}
+function getPresetNames() {
+	return [...presets.keys()];
+}
+function getPresetAliases() {
+	return new Map(presetNames);
+}
+const cloudflarePreset = definePreset({
+	capabilities: createCapabilitySet({
+		staticServe: true,
+		websocket: true,
+		sse: true,
+		cronTriggers: true,
+		queues: true,
+		kv: true,
+		storage: true,
+		database: true,
+		envVars: true,
+		secrets: true,
+		nodeCompat: false,
+		streaming: true,
+		compression: false,
+		https: true,
+		http2: false,
+		middleware: true,
+		bodyLimit: true,
+		multipart: true,
+		rpc: false
+	}),
+	entry: "worker",
+	exportConditions: ["workerd", "worker"],
+	build: {
+		outputDir: "dist/cloudflare",
+		format: "esm",
+		minify: false,
+		externals: [
+			"hono",
+			"c12",
+			"citty",
+			"consola",
+			"defu",
+			"hookable",
+			"pathe",
+			"ufo",
+			"zod",
+			"cloudflare:workers"
+		],
+		rollupConfig: { external: ["cloudflare:*", "node:*"] }
+	},
+	output: {
+		dir: "dist/cloudflare",
+		serverDir: "dist/cloudflare",
+		publicDir: "dist/cloudflare/public"
+	},
+	runtime: {
+		entry: "worker/index.mjs",
+		handler: "fetch",
+		compatibilityDate: "2024-09-01",
+		compatibilityFlags: ["nodejs_compat"]
+	},
+	wasm: {
+		lazy: false,
+		esmImport: true
+	},
+	serve: {
+		host: "localhost",
+		port: 8787
+	},
+	commands: {
+		preview: "npx wrangler dev",
+		deploy: "npx wrangler deploy"
+	},
+	hooks: {
+		"build:before": async () => {},
+		compiled: async () => {}
+	}
+}, {
+	name: "cloudflare",
+	aliases: [
+		"cloudflare-pages",
+		"cloudflare-module",
+		"cf",
+		"wrangler",
+		"workers"
+	],
+	stdName: "cloudflare_workers",
+	dev: true,
+	compatibilityDate: "2024-09-01"
+});
+const cloudflareDevPreset = definePreset({
+	extends: "cloudflare",
+	devServer: { runner: "miniflare" }
+}, {
+	name: "cloudflare-dev",
+	aliases: ["cf-dev", "wrangler-dev"],
+	dev: true
+});
+function generateWranglerConfig(options) {
+	const config = {
+		name: options.name,
+		main: options.entry || "dist/cloudflare/worker/index.mjs",
+		compatibility_date: options.compatibilityDate || "2024-09-01",
+		compatibility_flags: options.compatibilityFlags || ["nodejs_compat"],
+		workers_dev: true,
+		observability: { enabled: options.observability ?? true }
+	};
+	if (options.kvNamespaces && options.kvNamespaces.length > 0) config.kv_namespaces = options.kvNamespaces.map((ns) => ({
+		binding: ns.binding,
+		id: ns.id
+	}));
+	if (options.vars && Object.keys(options.vars).length > 0) config.vars = options.vars;
+	if (options.d1Databases && options.d1Databases.length > 0) config.d1_databases = options.d1Databases.map((db) => ({
+		binding: db.binding,
+		database_id: db.databaseId
+	}));
+	if (options.r2Buckets && options.r2Buckets.length > 0) config.r2_buckets = options.r2Buckets.map((b) => ({
+		binding: b.binding,
+		bucket_name: b.bucketName
+	}));
+	if (options.queuesProducers && options.queuesProducers.length > 0) config.queues = {
+		...config.queues,
+		producers: options.queuesProducers
+	};
+	if (options.queuesConsumers && options.queuesConsumers.length > 0) config.queues = {
+		...config.queues,
+		consumers: options.queuesConsumers
+	};
+	if (options.assetsDir) config.assets = {
+		directory: options.assetsDir,
+		binding: "ASSETS"
+	};
+	return config;
+}
+function serializeWranglerToml(config) {
+	const lines = [];
+	const indent = "";
+	function push(key, value, prefix = "") {
+		if (value === void 0 || value === null) return;
+		if (typeof value === "string") lines.push(`${prefix}${key} = "${escapeToml(value)}"`);
+		else if (typeof value === "boolean") lines.push(`${prefix}${key} = ${value}`);
+		else if (typeof value === "number") lines.push(`${prefix}${key} = ${value}`);
+		else if (Array.isArray(value)) {
+			if (value.length === 0) return;
+			if (typeof value[0] === "string") {
+				const items = value.map((v) => `"${escapeToml(String(v))}"`).join(", ");
+				lines.push(`${prefix}${key} = [${items}]`);
+			} else {
+				lines.push(`${prefix}[[${key}]]`);
+				for (const item of value) lines.push(`${prefix}  { ${Object.entries(item).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => {
+					if (typeof v === "string") return `${k} = "${escapeToml(v)}"`;
+					if (typeof v === "boolean") return `${k} = ${v}`;
+					return `${k} = ${v}`;
+				}).join(", ")} }`);
+			}
+		} else if (typeof value === "object") {
+			const entries = Object.entries(value).filter(([, v]) => v !== void 0 && v !== null);
+			if (entries.length === 0) return;
+			lines.push(`${prefix}[${key}]`);
+			for (const [k, v] of entries) if (Array.isArray(v) && typeof v[0] !== "string" && v.length > 0) {
+				lines.push(`${prefix}[[${key}.${k}]]`);
+				for (const item of v) {
+					const itemEntries = Object.entries(item).filter(([, iv]) => iv !== void 0 && iv !== null);
+					lines.push(itemEntries.map(([ik, iv]) => {
+						if (typeof iv === "string") return `${prefix}  ${ik} = "${escapeToml(iv)}"`;
+						return `${prefix}  ${ik} = ${iv}`;
+					}).join("\n"));
+				}
+			} else if (typeof v === "string") lines.push(`${prefix}${k} = "${escapeToml(v)}"`);
+			else if (typeof v === "boolean") lines.push(`${prefix}${k} = ${v}`);
+			else if (typeof v === "number") lines.push(`${prefix}${k} = ${v}`);
+		}
+	}
+	push("name", config.name);
+	push("main", config.main);
+	push("compatibility_date", config.compatibility_date);
+	push("compatibility_flags", config.compatibility_flags);
+	push("workers_dev", config.workers_dev);
+	if (config.routes && config.routes.length > 0) push("routes", config.routes);
+	if (config.assets) push("assets", config.assets);
+	if (config.observability) push("observability", config.observability);
+	if (config.kv_namespaces && config.kv_namespaces.length > 0) for (const ns of config.kv_namespaces) {
+		const nsLines = [`${indent}[[kv_namespaces]]`];
+		if (ns.binding) nsLines.push(`${indent}binding = "${escapeToml(ns.binding)}"`);
+		if (ns.id) nsLines.push(`${indent}id = "${escapeToml(ns.id)}"`);
+		if (ns.preview_id) nsLines.push(`${indent}preview_id = "${escapeToml(ns.preview_id)}"`);
+		lines.push(nsLines.join("\n"));
+	}
+	if (config.vars && Object.keys(config.vars).length > 0) {
+		lines.push(`${indent}[vars]`);
+		for (const [k, v] of Object.entries(config.vars)) lines.push(`${indent}${k} = "${escapeToml(v)}"`);
+	}
+	if (config.d1_databases && config.d1_databases.length > 0) for (const db of config.d1_databases) {
+		const dbLines = [`${indent}[[d1_databases]]`];
+		if (db.binding) dbLines.push(`${indent}binding = "${escapeToml(db.binding)}"`);
+		if (db.database_id) dbLines.push(`${indent}database_id = "${escapeToml(db.database_id)}"`);
+		if (db.preview_database_id) dbLines.push(`${indent}preview_database_id = "${escapeToml(db.preview_database_id)}"`);
+		lines.push(dbLines.join("\n"));
+	}
+	if (config.r2_buckets && config.r2_buckets.length > 0) for (const b of config.r2_buckets) {
+		const bLines = [`${indent}[[r2_buckets]]`];
+		if (b.binding) bLines.push(`${indent}binding = "${escapeToml(b.binding)}"`);
+		if (b.bucket_name) bLines.push(`${indent}bucket_name = "${escapeToml(b.bucket_name)}"`);
+		if (b.preview_bucket_name) bLines.push(`${indent}preview_bucket_name = "${escapeToml(b.preview_bucket_name)}"`);
+		lines.push(bLines.join("\n"));
+	}
+	if (config.queues) {
+		if (config.queues.producers && config.queues.producers.length > 0) for (const p of config.queues.producers) {
+			const pLines = [`${indent}[[queues.producers]]`];
+			if (p.binding) pLines.push(`${indent}binding = "${escapeToml(p.binding)}"`);
+			if (p.queue) pLines.push(`${indent}queue = "${escapeToml(p.queue)}"`);
+			lines.push(pLines.join("\n"));
+		}
+		if (config.queues.consumers && config.queues.consumers.length > 0) for (const c of config.queues.consumers) {
+			const cLines = [`${indent}[[queues.consumers]]`];
+			if (c.queue) cLines.push(`${indent}queue = "${escapeToml(c.queue)}"`);
+			lines.push(cLines.join("\n"));
+		}
+	}
+	return `${lines.join("\n")}\n`;
+}
+function escapeToml(str) {
+	return str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+//#endregion
+//#region src/node.ts
+const nodePreset = definePreset({
+	extends: "standard",
+	capabilities: NODE_CAPABILITIES,
+	build: {
+		outputDir: "dist",
+		format: "esm",
+		externals: [
+			"hono",
+			"c12",
+			"citty",
+			"consola",
+			"defu",
+			"hookable",
+			"pathe",
+			"ufo",
+			"zod",
+			"mlly",
+			"rou3",
+			"scule",
+			"tinyglobby",
+			"ofetch",
+			"@standard-schema/spec"
+		]
+	},
+	runtime: {
+		entry: "server/index.mjs",
+		handler: "handler"
+	},
+	serve: {
+		host: "localhost",
+		port: 9527
+	},
+	commands: { preview: "node dist/server/server.mjs" }
+}, {
+	name: "node",
+	aliases: ["node-server", "nodedev"],
+	stdName: "node",
+	dev: true,
+	compatibilityDate: "2024-09-01"
+});
+//#endregion
+//#region src/standard.ts
+const standardPreset = definePreset({
+	capabilities: STANDARD_CAPABILITIES,
+	build: {
+		outputDir: "dist",
+		format: "esm",
+		externals: [
+			"hono",
+			"c12",
+			"citty",
+			"consola",
+			"defu",
+			"hookable",
+			"pathe",
+			"ufo",
+			"zod"
+		]
+	},
+	runtime: { entry: "server" },
+	serve: {
+		host: "localhost",
+		port: 9527
+	}
+}, {
+	name: "standard",
+	aliases: ["default"],
+	static: false,
+	dev: true
+});
+//#endregion
+//#region src/detect.ts
+function getPresetDef(preset) {
+	return typeof preset === "function" ? preset() : preset;
+}
+function detectByConfigFiles(cwd) {
+	if (existsSync(join(cwd, "wrangler.toml")) || existsSync(join(cwd, "wrangler.json"))) return "cloudflare";
+	if (existsSync(join(cwd, "package.json"))) try {
+		const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+		const deps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if ("wrangler" in deps || "@cloudflare/workers-types" in deps) return "cloudflare";
+	} catch {}
+	return null;
+}
+function detectByEnvironment(env, g) {
+	if (env.CF_WORKERS || env.WRANGLER || env.CLOUDFLARE_WORKER) return "cloudflare";
+	if (env.NODE_ENV === void 0 && "process" in g) return "node";
+	const gRecord = g;
+	if (gRecord.CacheStorage !== void 0 && gRecord.Deno === void 0 && gRecord.process === void 0) return "cloudflare";
+	if (gRecord.process !== void 0) {
+		if (gRecord.process.versions?.node) return "node";
+	}
+	return null;
+}
+function resolvePresetByNameSafe(name) {
+	return resolvePreset(getPresetAliases().get(name) || name) || null;
+}
+function detectPreset(hints = {}) {
+	const cwd = hints.cwd || process.cwd();
+	const env = hints.environment || (typeof process !== "undefined" ? process.env : {});
+	const g = hints.globalThis || (typeof globalThis !== "undefined" ? globalThis : {});
+	if (hints.explicitPreset) {
+		const explicit = resolvePresetByNameSafe(hints.explicitPreset);
+		if (explicit) return {
+			preset: explicit,
+			source: "explicit",
+			reason: `explicitly set to "${hints.explicitPreset}"`
+		};
+	}
+	const configDetected = detectByConfigFiles(cwd);
+	if (configDetected) {
+		const preset = resolvePresetByNameSafe(configDetected);
+		if (preset) return {
+			preset,
+			source: "config-file",
+			reason: configDetected === "cloudflare" ? "detected wrangler.toml or Cloudflare dependencies" : `detected ${configDetected} configuration`
+		};
+	}
+	const envDetected = detectByEnvironment(env, g);
+	if (envDetected) {
+		const preset = resolvePresetByNameSafe(envDetected);
+		if (preset) return {
+			preset,
+			source: "environment",
+			reason: `detected ${envDetected} runtime environment`
+		};
+	}
+	return {
+		preset: resolvePresetByNameSafe("standard"),
+		source: "default",
+		reason: "no specific platform detected, using standard preset"
+	};
+}
+function resolvePresetWithDetection(explicitPreset, cwd) {
+	return detectPreset({
+		explicitPreset,
+		cwd
+	});
+}
+function listDetectablePresets() {
+	return [
+		getPresetDef(standardPreset),
+		getPresetDef(nodePreset),
+		getPresetDef(cloudflarePreset),
+		getPresetDef(cloudflareDevPreset)
+	];
+}
+//#endregion
+//#region src/index.ts
+const builtinPresets = [
+	standardPreset,
+	nodePreset,
+	cloudflarePreset,
+	cloudflareDevPreset
+];
+function registerBuiltinPresets() {
+	for (const preset of builtinPresets) registerPreset(preset);
+}
+registerBuiltinPresets();
+function resolvePresetByName(name) {
+	const preset = resolvePreset(getPresetAliases().get(name) || name);
+	if (preset) return preset;
+	const standardResolved = resolvePreset("standard");
+	if (standardResolved) return standardResolved;
+	return {
+		name: "standard",
+		_meta: { name: "standard" },
+		serve: {
+			host: "localhost",
+			port: 9527
+		},
+		build: {
+			outputDir: "dist",
+			format: "esm",
+			externals: []
+		},
+		runtime: { entry: "server" },
+		capabilities: {},
+		hooks: {},
+		commands: {}
+	};
+}
+//#endregion
+export { DEV_REQUIREMENTS, NODE_CAPABILITIES, NODE_REQUIREMENTS, STANDARD_CAPABILITIES, WORKER_CAPABILITIES, cloudflareDevPreset, cloudflarePreset, createCapabilitySet, definePreset, detectPreset, diagnoseCapabilities, generateWranglerConfig, getPresetAliases, getPresetNames, getRegisteredPresets, listDetectablePresets, nodePreset, registerBuiltinPresets, registerPreset, requireCapability, resolvePreset, resolvePresetByName, resolvePresetWithDetection, serializeWranglerToml, standardPreset };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/preset",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Deployment presets for ubean (standard, node, cloudflare, wrangler config)",
   "files": [
     "dist"