@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/src/accepts.ts

@@ -1,136 +0,0 @@
-type ParsedType = {
-	/** Position in the header, for stable tie-breaking. */
-	index: number
-	/** Media-type parameters other than q, names lowercased (more parameters = more specific). */
-	params: Map<string, string>
-	q: number
-	subtype: string
-	type: string
-}
-
-/** RFC 9110 §12.4.2: qvalue = ( "0" [ "." 0*3DIGIT ] ) / ( "1" [ "." 0*3("0") ] ). Lenient on digit count. */
-function parseQ(raw: string): number | null {
-	if (!/^(?:0(?:\.\d*)?|1(?:\.0*)?|\.\d+)$/.test(raw)) return null
-	const q = Number(raw)
-	return q >= 0 && q <= 1 ? q : null
-}
-
-function parseAccept(header: string): ParsedType[] {
-	const types: ParsedType[] = []
-	const parts = header.split(",")
-	for (let index = 0; index < parts.length; index++) {
-		const trimmed = parts[index].trim()
-		if (trimmed.length === 0) continue
-
-		const segments = trimmed.split(";")
-		const mediaType = segments[0].trim().toLowerCase()
-		const slash = mediaType.indexOf("/")
-		if (slash <= 0 || slash === mediaType.length - 1) continue
-		const type = mediaType.slice(0, slash)
-		const subtype = mediaType.slice(slash + 1)
-		/* `*\/html` is not a valid range. */
-		if (type === "*" && subtype !== "*") continue
-
-		let q = 1
-		const params = new Map<string, string>()
-		for (let i = 1; i < segments.length; i++) {
-			const eq = segments[i].indexOf("=")
-			if (eq === -1) continue
-			const name = segments[i].slice(0, eq).trim().toLowerCase()
-			const value = segments[i].slice(eq + 1).trim()
-			if (name === "q") {
-				const parsed = parseQ(value)
-				/* An unparsable weight makes the whole range unusable rather than silently q=1. */
-				q = parsed ?? 0
-				/* Parameters after q are accept-extensions, not media-type parameters. */
-				break
-			}
-			params.set(name, unquote(value))
-		}
-
-		types.push({ index, params, q, subtype, type })
-	}
-	return types
-}
-
-function unquote(value: string): string {
-	return value.length >= 2 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value
-}
-
-/** `type/subtype;a=1;b=2` → its parameters, names lowercased. */
-function typeParams(segments: string[]): Map<string, string> {
-	const params = new Map<string, string>()
-	for (let i = 1; i < segments.length; i++) {
-		const eq = segments[i].indexOf("=")
-		if (eq === -1) continue
-		params.set(segments[i].slice(0, eq).trim().toLowerCase(), unquote(segments[i].slice(eq + 1).trim()))
-	}
-	return params
-}
-
-/**
- * 0 = no match; otherwise higher is more specific. A range with parameters matches only a
- * supported type that carries every one of them with the same value (RFC 9110 §12.5.1), so
- * `application/json;v=2;q=0` excludes `application/json;v=2`, never plain `application/json`.
- */
-function specificity(range: ParsedType, sType: string, sSub: string, sParams: Map<string, string>): number {
-	if (range.type === "*") return 1
-	if (range.type !== sType) return 0
-	if (range.subtype === "*") return 2
-	if (range.subtype !== sSub) return 0
-	for (const [name, value] of range.params) {
-		if (sParams.get(name) !== value) return 0
-	}
-	return 3 + range.params.size
-}
-
-/**
- * Pick the best supported content type based on the request's Accept header.
- *
- * Each supported type takes the weight of the most specific range that matches
- * it (RFC 9110 §12.5.1), so `text/html;q=0, *\/*` excludes `text/html`. Among
- * types with equal weight, the server's order in `supported` wins.
- *
- * Returns null if no match found. Returns the first supported type if there is
- * no Accept header.
- */
-export function accepts(req: Request, supported: string[]): string | null {
-	const header = req.headers.get("accept")
-	if (header === null || header.trim().length === 0) {
-		return supported[0] ?? null
-	}
-
-	const parsed = parseAccept(header)
-	if (parsed.length === 0) {
-		return supported[0] ?? null
-	}
-
-	let bestMatch: string | null = null
-	let bestQ = 0
-
-	for (const s of supported) {
-		const lower = s.toLowerCase()
-		const slash = lower.indexOf("/")
-		if (slash === -1) continue
-		const sType = lower.slice(0, slash)
-		const sSegments = s.slice(slash + 1).split(";")
-		const sSub = sSegments[0].trim().toLowerCase()
-		const sParams = typeParams(sSegments)
-
-		let weight = -1
-		let bestSpecificity = 0
-		for (const range of parsed) {
-			const spec = specificity(range, sType, sSub, sParams)
-			if (spec > bestSpecificity) {
-				bestSpecificity = spec
-				weight = range.q
-			}
-		}
-		if (weight > bestQ) {
-			bestQ = weight
-			bestMatch = s
-		}
-	}
-
-	return bestMatch
-}

package/src/body-kind.ts

@@ -1,67 +0,0 @@
-import { isHoneyResponse, replaceResponse } from "./honey-response.ts"
-import { BODY_KIND } from "./producer-stream.ts"
-
-/** Set by `ctx.res.json/text/html/...` on native responses built from in-memory bytes. */
-const RAW_BODY = Symbol.for("honey.rawBody")
-
-/** The in-memory body of a response Honey built from a string or bytes, if any. */
-export function rawBodyOf(response: Response): string | Uint8Array | null {
-	if (isHoneyResponse(response)) return response.rawBody
-	return (response as Response & { [RAW_BODY]?: string | Uint8Array })[RAW_BODY] ?? null
-}
-
-/**
- * What kind of body a response carries, decided without reading it.
- *
- * - `empty`: no body.
- * - `buffered`: the whole body is already in memory (a response Honey built
- *   from a string or bytes) or its size is declared by `content-length`, so
- *   reading it is bounded.
- * - `stream`: anything else (SSE, `generate()`, `new Response(stream)`, a
- *   proxied `fetch()` without a length). Middleware must not buffer it.
- *
- * Content type is never consulted: SSE and NDJSON streams carry one.
- * Honey's own responses are tagged when they are created: buffered ones by their raw body,
- * streams by `BODY_KIND`. An untagged native response is a stream unless it declares a length.
- */
-export function bodyKind(response: Response): "buffered" | "empty" | "stream" {
-	if (rawBodyOf(response) !== null) return "buffered"
-	/* `sse()`, `stream()` and `generate()` tag their responses at creation */
-	if ((response as Response & { [BODY_KIND]?: string })[BODY_KIND] === "stream") return "stream"
-	if (isHoneyResponse(response)) {
-		/* `body` is the stream (or null) when no raw bytes exist; reading it does not allocate. */
-		return response.body === null ? "empty" : "stream"
-	}
-	if (response.body === null) return "empty"
-	const length = response.headers.get("content-length")
-	if (length !== null && /^\d+$/.test(length.trim())) return "buffered"
-	return "stream"
-}
-
-/** A stream `sse()`, `stream()` or `generate()` created: possibly endless, never to be buffered. */
-export function isProducedStream(response: Response): boolean {
-	return (response as Response & { [BODY_KIND]?: string })[BODY_KIND] === "stream"
-}
-
-function noop(): void {}
-
-/**
- * The response to a HEAD request: same status and headers, no body. A body Honey built in
- * memory keeps its `content-length`, so HEAD reports the size GET would send; a stream is
- * cancelled unread, so its producer never starts (or stops if it already did).
- */
-export function headResponse(response: Response): Response {
-	if (response.status === 101) return response
-	const raw = rawBodyOf(response)
-	const headers = new Headers(response.headers as HeadersInit)
-	if (raw !== null) {
-		if (!headers.has("content-length")) {
-			const length = typeof raw === "string" ? new TextEncoder().encode(raw).byteLength : raw.byteLength
-			headers.set("content-length", String(length))
-		}
-	} else {
-		const body = response.body
-		if (body !== null && !body.locked) body.cancel().catch(noop)
-	}
-	return replaceResponse(response, { body: null, headers })
-}

package/src/body-limit.ts

@@ -1,152 +0,0 @@
-import { namedMiddleware } from "./middleware.ts"
-import { HoneyError } from "./error.ts"
-import { parseMediaType } from "./media-type.ts"
-import type { MiddlewareFn } from "./middleware.ts"
-import { EK, SK } from "./types.ts"
-
-type BodyLimitOptions = {
-	/**
-	 * Per media-type size limits. A key matches when the request's media type
-	 * (lowercased, parameters dropped) starts with it, so `"multipart/"` covers
-	 * every multipart type. The longest matching key wins.
-	 */
-	limits?: Record<string, number>
-	/** Default max body size in bytes — used when no content-type match or no limits map */
-	maxSize: number
-	/**
-	 * Skip stream byte-counting when Content-Length header is present and within bounds.
-	 * HTTP/1.1 and HTTP/2 framing guarantees body cannot exceed declared Content-Length
-	 * regardless of TLS — the protocol enforces it at the transport level.
-	 * When false, every request body is wrapped in a counting TransformStream even
-	 * when Content-Length is present. Chunked requests (no Content-Length) are always
-	 * stream-counted regardless of this setting.
-	 * Default: false.
-	 */
-	trustContentLength?: boolean
-}
-
-export type { BodyLimitOptions }
-
-/* After an overflow the rest of the upload is read and discarded so the client
- * sees the 413 instead of a reset, but only this much: past it the stream is
- * cancelled, so a client cannot hold the connection open with an endless body. */
-const DRAIN_LIMIT = 1_048_576
-
-/* the shared parser lowercases and drops parameters; a malformed type matches no key */
-function mediaType(contentType: string | null): string | null {
-	return parseMediaType(contentType)?.essence ?? null
-}
-
-function tooLarge(): HoneyError {
-	return new HoneyError({ errorKey: EK.content_too_large, status: SK.content_too_large })
-}
-
-export function bodyLimit(opts: BodyLimitOptions): MiddlewareFn<{ req: Request }, {}> {
-	const { limits, maxSize, trustContentLength } = opts
-	const limitEntries =
-		limits !== undefined
-			? Object.entries(limits)
-					.map(([key, limit]) => [key.trim().toLowerCase(), limit] as const)
-					.sort((a, b) => b[0].length - a[0].length)
-			: null
-
-	const resolveMax = (req: Request): number => {
-		if (limitEntries === null) return maxSize
-		const type = mediaType(req.headers.get("content-type"))
-		if (type === null) return maxSize
-		for (const [key, limit] of limitEntries) {
-			if (type.startsWith(key)) return limit
-		}
-		return maxSize
-	}
-
-	/* every method: a DELETE or PROPFIND with a body is as large as a POST */
-	const mw: MiddlewareFn<{ req: Request }, {}> = (ctx, next) => {
-		const req = ctx.req
-		const contentLength = req.headers.get("content-length")
-		const body = req.body
-		if (body === null && contentLength === null) return next()
-
-		const limit = resolveMax(req)
-
-		/* fast path: Content-Length header present */
-		if (contentLength !== null) {
-			const len = Number.parseInt(contentLength, 10)
-			if (!Number.isNaN(len) && len > limit) throw tooLarge()
-			if (trustContentLength === true) return next()
-		}
-
-		/* slow path: stream-count when no Content-Length (chunked) or trustContentLength disabled.
-		 * On overflow, error the downstream consumer then drain (do not cancel) the upstream —
-		 * cancelling an undici FormData body mid-encode enqueues into a closed stream on Node 24. */
-		if (body === null) return next()
-
-		let totalBytes = 0
-		let overflowed = false
-		const reader = body.getReader()
-
-		const drainUpstream = (): void => {
-			void (async () => {
-				let drained = 0
-				try {
-					while (true) {
-						const r = await reader.read()
-						if (r.done) break
-						drained += r.value.byteLength
-						if (drained > DRAIN_LIMIT) {
-							await reader.cancel()
-							break
-						}
-					}
-				} catch {
-					/* producer may already be done */
-				}
-			})()
-		}
-
-		const limited = new ReadableStream<Uint8Array>({
-			cancel() {
-				/* consumer aborted — still drain so undici FormData encoders can finish */
-				drainUpstream()
-			},
-			async pull(controller) {
-				if (overflowed) return
-				let result: ReadableStreamReadResult<Uint8Array>
-				try {
-					result = await reader.read()
-				} catch (err) {
-					controller.error(err)
-					return
-				}
-				if (result.done) {
-					controller.close()
-					return
-				}
-				totalBytes += result.value.byteLength
-				if (totalBytes > limit) {
-					overflowed = true
-					controller.error(tooLarge())
-					drainUpstream()
-					return
-				}
-				controller.enqueue(result.value)
-			},
-		})
-
-		const replaceBody = (req as unknown as Record<symbol, unknown>)[Symbol.for("honey.replaceBody")]
-		if (typeof replaceBody === "function") {
-			;(replaceBody as (stream: ReadableStream<Uint8Array>) => void).call(req, limited)
-		} else {
-			/* duplex: "half" required by Node/undici when body is a ReadableStream */
-			const newReq = new Request(req, {
-				body: limited,
-				duplex: "half",
-			} as RequestInit)
-			Object.defineProperty(ctx, "req", { configurable: true, value: newReq })
-		}
-
-		return next()
-	}
-
-	return namedMiddleware("bodyLimit", mw)
-}

package/src/build/index.ts

@@ -1,217 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { builtinModules } from "node:module"
-import { extname, resolve } from "node:path"
-import { detectFeaturesInSource, FEATURES, featurePrelude, type HoneyFeature, scanProgram } from "../feature-detect.ts"
-
-/* ---- Public types ---- */
-
-export type HoneyBuildConfig = {
-	external?: string[]
-	/**
-	 * Force optional features on or off. Unset features are detected by scanning the app's
-	 * import graph for `.openapi()` / `.manifest()`, `.errorI18n()` and `.serve()` calls.
-	 */
-	features?: Partial<Record<HoneyFeature, boolean>>
-	minify?: boolean
-	outDir?: string
-	port?: number
-	target: "bun" | "cloudflare" | "deno" | "node"
-}
-
-/* ---- Internal types ---- */
-
-type ResolvedBuildConfig = {
-	entry: string
-	export: string
-	port: number
-}
-
-type BuildAdapterDef = {
-	entry(config: ResolvedBuildConfig): string
-	/** Bundle every dependency. Workers have no node_modules at run time. */
-	noExternal: boolean
-	/** Features the target can never use. */
-	skipFeatures: HoneyFeature[]
-	ssrTarget: "node" | "webworker"
-}
-
-/* ---- Entry helpers ---- */
-
-function importApp(entry: string, exportName: string): string {
-	if (exportName === "default") return `import app from "./${entry}"`
-	return `import { ${exportName} as app } from "./${entry}"`
-}
-
-/* server targets start through the same code path as `app.serve()`: WS adapter, env, hostname */
-function serverEntry(config: ResolvedBuildConfig, runtime: "bun" | "deno" | "node", env: string, port: string): string {
-	return [
-		'import { startHoneyServer } from "@lovrozagar/honey/serve"',
-		importApp(config.entry, config.export),
-		"",
-		`const port = Number(${port})`,
-		`await startHoneyServer(app, { env: ${env}, hostname: "0.0.0.0", port, runtime: "${runtime}" })`,
-	].join("\n")
-}
-
-/* ---- Adapter definitions ---- */
-
-const adapters: Record<HoneyBuildConfig["target"], BuildAdapterDef> = {
-	bun: {
-		entry: (config) => serverEntry(config, "bun", "process.env", `process.env.PORT ?? ${config.port}`),
-		noExternal: false,
-		skipFeatures: [],
-		ssrTarget: "node",
-	},
-	cloudflare: {
-		entry(config) {
-			return [
-				importApp(config.entry, config.export),
-				"",
-				"export default {",
-				"  fetch: (req, env, ctx) => app.fetch(req, env, ctx),",
-				"}",
-			].join("\n")
-		},
-		noExternal: true,
-		/* a Worker cannot listen; serve would pull node:http into the bundle */
-		skipFeatures: ["serve"],
-		ssrTarget: "webworker",
-	},
-	deno: {
-		entry: (config) => serverEntry(config, "deno", "Deno.env.toObject()", `Deno.env.get("PORT") ?? "${config.port}"`),
-		noExternal: true,
-		skipFeatures: [],
-		ssrTarget: "webworker",
-	},
-	node: {
-		entry: (config) => serverEntry(config, "node", "process.env", `process.env.PORT ?? ${config.port}`),
-		noExternal: false,
-		skipFeatures: [],
-		ssrTarget: "node",
-	},
-}
-
-/* ---- Feature detection over the import graph ---- */
-
-const SCANNED_EXT = /\.(?:[cm]?[jt]sx?)$/
-
-type ParseContext = {
-	parse?: (code: string, options?: { lang?: "js" | "jsx" | "ts" | "tsx" }) => unknown
-	resolve?: (source: string, importer?: string) => Promise<{ external?: unknown; id: string } | null>
-}
-
-function langOf(file: string): "js" | "jsx" | "ts" | "tsx" {
-	const ext = extname(file)
-	if (ext === ".tsx") return "tsx"
-	if (ext === ".jsx") return "jsx"
-	return /^\.[cm]?ts$/.test(ext) ? "ts" : "js"
-}
-
-/**
- * Walks the app's own modules (never node_modules) from `entry`, following static and dynamic
- * imports, and collects feature calls. Comments and strings do not count.
- */
-async function detectGraphFeatures(ctx: ParseContext, entry: string): Promise<Set<HoneyFeature>> {
-	const features = new Set<HoneyFeature>()
-	const seen = new Set<string>()
-	const queue = [entry]
-	while (queue.length > 0) {
-		const file = queue.pop() as string
-		if (seen.has(file)) continue
-		seen.add(file)
-		if (!SCANNED_EXT.test(file) || file.includes("node_modules") || !existsSync(file)) continue
-		const code = readFileSync(file, "utf-8")
-
-		let imports: string[] = []
-		let program: unknown
-		try {
-			program = ctx.parse?.(code, { lang: langOf(file) })
-		} catch {
-			program = undefined
-		}
-		if (program) {
-			const scanned = scanProgram(program)
-			for (const f of scanned.features) features.add(f)
-			imports = scanned.imports
-		} else {
-			for (const f of detectFeaturesInSource(code)) features.add(f)
-		}
-
-		if (!ctx.resolve) continue
-		for (const source of imports) {
-			const resolved = await ctx.resolve(source, file).catch(() => null)
-			if (!resolved || resolved.external || resolved.id.startsWith("\0")) continue
-			queue.push(resolved.id.split("?")[0] as string)
-		}
-	}
-	return features
-}
-
-/* ---- Virtual module constants ---- */
-
-const VIRTUAL_BUILD_ENTRY = "virtual:honey-build-entry"
-const RESOLVED_BUILD_ENTRY = `\0${VIRTUAL_BUILD_ENTRY}`
-
-/* ---- Build plugin factory ---- */
-
-export function createBuildPlugin(buildConfig: HoneyBuildConfig, shared: { entry: string; export: string }) {
-	const adapter = adapters[buildConfig.target]
-	const resolvedConfig: ResolvedBuildConfig = {
-		entry: shared.entry,
-		export: shared.export,
-		port: buildConfig.port ?? 3000,
-	}
-
-	let root = ""
-
-	return {
-		apply: "build" as const,
-
-		config() {
-			return {
-				build: {
-					emptyOutDir: false,
-					minify: buildConfig.minify ?? true,
-					outDir: buildConfig.outDir ?? "./dist",
-					rolldownOptions: {
-						external: [...builtinModules, ...builtinModules.map((m) => `node:${m}`), ...(buildConfig.external ?? [])],
-						input: VIRTUAL_BUILD_ENTRY,
-						output: { entryFileNames: "index.js" },
-					},
-					ssr: true,
-				},
-				ssr: {
-					/* node and bun install dependencies next to the bundle; inlining them would also inline native addons */
-					...(adapter.noExternal ? { noExternal: true } : {}),
-					target: adapter.ssrTarget,
-				},
-			}
-		},
-
-		configResolved(cfg: { root: string }) {
-			root = cfg.root
-		},
-
-		async load(this: ParseContext | undefined, id: string): Promise<{ code: string; moduleType: string } | undefined> {
-			if (id !== RESOLVED_BUILD_ENTRY) return undefined
-			const appPath = resolve(root || ".", shared.entry)
-			const detected = await detectGraphFeatures(this ?? {}, appPath)
-			const features = FEATURES.filter((feature) => {
-				if (adapter.skipFeatures.includes(feature)) return false
-				return buildConfig.features?.[feature] ?? detected.has(feature)
-			})
-			const prelude = featurePrelude(features)
-			return {
-				code: `${prelude ? `${prelude}\n` : ""}${adapter.entry(resolvedConfig)}`,
-				moduleType: "js",
-			}
-		},
-
-		name: "honey:build",
-
-		resolveId(id: string): string | undefined {
-			if (id === VIRTUAL_BUILD_ENTRY) return RESOLVED_BUILD_ENTRY
-			return undefined
-		},
-	}
-}

package/src/cli-args.ts

@@ -1,123 +0,0 @@
-/** Argument parsing for the `honey` CLI. Not a package export. */
-
-export const USAGE = `Usage: honey generate [options]
-       honey init [--cf] [--force]
-
-generate options:
-  --config <path>          Vite config holding honey() (default: vite.config.{ts,mts,js,mjs,…})
-  --plugin <n>             Which honey() plugin in the config, 0-based (when there are several)
-  --app <path>             App entry; overrides the config's app, or replaces the config
-  --watch                  Regenerate when files next to the app change
-  --tree --types --manifest --sdk
-                           Turn on an output
-  --merge-tree <path>      Route tree source for a gateway
-  --cli --cli-out <dir> --cli-binary-name <name> [--cli-config-name <name>]
-      [--cli-default-base-url <url>] [--cli-env-prefix <prefix>] [--cli-module-path <path>]
-      [--cli-sdk-module-path <path>]
-                           Generate the Go CLI
-  -h, --help               Show this help`
-
-export class UsageError extends Error {}
-
-export type CliFlags = {
-	app?: string
-	cli?: boolean
-	cliBinaryName?: string
-	cliConfigName?: string
-	cliDefaultBaseUrl?: string
-	cliEnvPrefix?: string
-	cliModulePath?: string
-	cliOut?: string
-	cliSdkModulePath?: string
-	config?: string
-	help?: boolean
-	manifest?: boolean
-	mergeTree?: string
-	plugin?: number
-	sdk?: boolean
-	tree?: boolean
-	types?: boolean
-	watch?: boolean
-}
-
-const BOOLEAN_FLAGS: Record<string, keyof CliFlags> = {
-	cli: "cli",
-	help: "help",
-	manifest: "manifest",
-	sdk: "sdk",
-	tree: "tree",
-	types: "types",
-	watch: "watch",
-}
-
-const VALUE_FLAGS: Record<string, keyof CliFlags> = {
-	app: "app",
-	"cli-binary-name": "cliBinaryName",
-	"cli-config-name": "cliConfigName",
-	"cli-default-base-url": "cliDefaultBaseUrl",
-	"cli-env-prefix": "cliEnvPrefix",
-	"cli-module-path": "cliModulePath",
-	"cli-out": "cliOut",
-	"cli-sdk-module-path": "cliSdkModulePath",
-	config: "config",
-	"merge-tree": "mergeTree",
-	plugin: "plugin",
-}
-
-/** Strict: unknown flags, stray positionals and missing values are errors. Accepts `--k v` and `--k=v`. */
-export function parseGenerateArgs(args: string[]): CliFlags {
-	const flags: Record<string, unknown> = {}
-	for (let i = 0; i < args.length; i++) {
-		const arg = args[i] as string
-		if (arg === "-h") {
-			flags.help = true
-			continue
-		}
-		if (!arg.startsWith("--") || arg === "--") throw new UsageError(`unexpected argument: ${arg}`)
-		const eq = arg.indexOf("=")
-		const name = eq === -1 ? arg.slice(2) : arg.slice(2, eq)
-		const inline = eq === -1 ? undefined : arg.slice(eq + 1)
-
-		const bool = BOOLEAN_FLAGS[name]
-		if (bool) {
-			if (inline === undefined || inline === "true") flags[bool] = true
-			else if (inline === "false") flags[bool] = false
-			else throw new UsageError(`--${name} takes no value (got "${inline}")`)
-			continue
-		}
-
-		const key = VALUE_FLAGS[name]
-		if (!key) throw new UsageError(`unknown option: --${name}`)
-		let value = inline
-		if (value === undefined) {
-			const next = args[i + 1]
-			if (next === undefined || next.startsWith("--")) throw new UsageError(`--${name} requires a value`)
-			value = next
-			i++
-		}
-		if (value === "") throw new UsageError(`--${name} requires a value`)
-		if (key === "plugin") {
-			if (!/^\d+$/.test(value)) throw new UsageError(`--plugin takes a non-negative integer (got "${value}")`)
-			flags.plugin = Number(value)
-		} else {
-			flags[key] = value
-		}
-	}
-	return flags as CliFlags
-}
-
-/** `honey init` flags. `--cloudflare` is an alias of `--cf`. */
-export type InitFlags = {
-	cf: boolean
-	force: boolean
-}
-
-export function parseInitFlags(args: string[]): InitFlags {
-	const flags: InitFlags = { cf: false, force: false }
-	for (const arg of args) {
-		if (arg === "--cf" || arg === "--cloudflare") flags.cf = true
-		else if (arg === "--force") flags.force = true
-		else throw new UsageError(arg.startsWith("-") ? `unknown option: ${arg}` : `unexpected argument: ${arg}`)
-	}
-	return flags
-}