asphodelos 0.0.1

package/dist/index.mjs

@@ -0,0 +1,202 @@
+import { Effect, FileSystem, Schema, SchemaIssue, SchemaTransformation } from "effect";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/config/index.ts
+/**
+* The config file is missing, is not a module with a default export, or does not validate.
+*
+* `notFound` separates "there is no config here" from "the config here is wrong": only the first
+* is the caller who ran `asphodelos` with nothing and needs to be told what the command accepts.
+* Everything else already names the field that is wrong.
+*
+* `Schema.TaggedError` rather than `Data.TaggedError`: this is the error a schema decode turns
+* into, which makes the failure a schema in its own right. The errors that never meet a schema
+* (`FormatError`, `GenerateError`, `OpenAPIError`) stay plain `Data.TaggedError`.
+*/
+var ConfigError = class extends Schema.TaggedError()("ConfigError", {
+	message: Schema.String,
+	notFound: Schema.optionalKey(Schema.Boolean)
+}) {};
+/**
+* A path constrained to a set of extensions.
+*
+* `Schema.TemplateLiteral` carries the literal type but its rejection reads "Expected a string
+* matching template literal parts"; `Schema.declare` over the same guard keeps the type on both
+* sides — so `defineConfig` still rejects a wrong extension while you type — and lets the message
+* say which extensions are meant.
+*/
+const TypeScriptPathSchema = Schema.declare(Schema.is(Schema.TemplateLiteral([Schema.String, ".ts"])), { message: "must be .ts file" });
+const InputSchema = Schema.declare(Schema.is(Schema.TemplateLiteral([Schema.String, Schema.Literals([
+	".yaml",
+	".json",
+	".tsp"
+])])), { message: "must be .yaml | .json | .tsp" });
+/** Milliseconds, bounded so a mock cannot be configured to hang a request. */
+const DelayMsSchema = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(6e4));
+/** A faker seed: faker hashes it with Mersenne Twister, which takes a 32-bit unsigned integer. */
+const SeedSchema = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(4294967295));
+/** How many items a generated array holds when the schema does not say. */
+const ArrayLengthSchema = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(1e3));
+/** A directory path normalizes to `<dir>/index.ts`, so single-file mode always names a file. */
+const FileOutputSchema = Schema.String.pipe(Schema.decodeTo(Schema.String, SchemaTransformation.transform({
+	decode: (v) => v.endsWith(".ts") ? v : `${v}/index.ts`,
+	encode: (v) => v
+})));
+/**
+* Every output target is the same two-branch union: `split: true` writes one file per entry into
+* a directory, anything else writes a single file. Only those two fields differ, so the rest is
+* written once and spread into both branches.
+*
+* `Schema.Union` resolves members in order and each member pins `split` to a literal, so a member
+* is only reachable through its own discriminant — the failure reported is the one inside the
+* matching branch, not a union-wide "no member matched".
+*/
+function splitUnion(shared) {
+	return Schema.Union([Schema.Struct({
+		split: Schema.Literal(true),
+		output: Schema.String.check(Schema.isPattern(/^(?!.*\.ts$).+/u, { message: "split mode requires directory, not .ts file" })),
+		...shared
+	}), Schema.Struct({
+		split: Schema.Literal(false).pipe(Schema.withDecodingDefault(Effect.succeed(false))),
+		output: FileOutputSchema,
+		...shared
+	})]);
+}
+const OutputSchema = splitUnion({ import: Schema.optionalKey(Schema.String) });
+const ExportTypesOutputSchema = splitUnion({
+	import: Schema.optionalKey(Schema.String),
+	exportTypes: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false)))
+});
+const HooksSchema = splitUnion({
+	import: Schema.String,
+	client: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed("client")))
+});
+const ComponentsSchema = Schema.Struct({
+	output: Schema.optionalKey(TypeScriptPathSchema),
+	schemas: Schema.optionalKey(ExportTypesOutputSchema),
+	responses: Schema.optionalKey(ExportTypesOutputSchema),
+	parameters: Schema.optionalKey(ExportTypesOutputSchema),
+	examples: Schema.optionalKey(OutputSchema),
+	requestBodies: Schema.optionalKey(ExportTypesOutputSchema),
+	headers: Schema.optionalKey(ExportTypesOutputSchema),
+	securitySchemes: Schema.optionalKey(OutputSchema),
+	links: Schema.optionalKey(OutputSchema),
+	callbacks: Schema.optionalKey(OutputSchema),
+	pathItems: Schema.optionalKey(OutputSchema),
+	mediaTypes: Schema.optionalKey(ExportTypesOutputSchema)
+}).check(Schema.makeFilter(({ output, ...perType }) => output === void 0 || Object.keys(perType).length === 0 ? void 0 : "output cannot be combined with per-type component outputs. Use either a single 'output' or per-type configs."));
+const ConfigSchema = Schema.Struct({
+	input: InputSchema,
+	output: Schema.optionalKey(TypeScriptPathSchema),
+	prefix: Schema.optionalKey(Schema.String),
+	format: Schema.optionalKey(Schema.declare((u) => typeof u === "object" && u !== null, { message: "must be an oxfmt config object" })),
+	port: Schema.optionalKey(Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed("3000")))),
+	pathAlias: Schema.optionalKey(Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false)))),
+	integration: Schema.optionalKey(Schema.Boolean),
+	readonly: Schema.optionalKey(Schema.Boolean),
+	components: Schema.optionalKey(ComponentsSchema),
+	eden: Schema.optionalKey(Schema.Struct({
+		output: Schema.String,
+		import: Schema.String,
+		client: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed("client"))),
+		docs: Schema.optionalKey(Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))))
+	})),
+	types: Schema.optionalKey(Schema.Struct({ output: TypeScriptPathSchema })),
+	test: Schema.optionalKey(Schema.Union([Schema.Struct({
+		split: Schema.Literal(true),
+		pathAlias: Schema.optionalKey(Schema.String)
+	}), Schema.Struct({
+		split: Schema.Literal(false).pipe(Schema.withDecodingDefault(Effect.succeed(false))),
+		output: FileOutputSchema,
+		pathAlias: Schema.optionalKey(Schema.String)
+	})])),
+	mock: Schema.optionalKey(Schema.Struct({
+		output: FileOutputSchema,
+		useExamples: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Literal("all")])),
+		seed: Schema.optionalKey(Schema.Union([SeedSchema, Schema.NonEmptyArray(SeedSchema)])),
+		locale: Schema.optionalKey(Schema.String.check(Schema.isPattern(/^[A-Za-z_]{1,40}$/u, { message: "must be a faker locale code such as 'ja', 'en' or 'zh_CN'" }))),
+		delay: Schema.optionalKey(Schema.Union([
+			DelayMsSchema,
+			Schema.Literal(false),
+			Schema.Struct({
+				min: DelayMsSchema,
+				max: DelayMsSchema
+			}).check(Schema.makeFilter(({ min, max }) => min <= max ? void 0 : "delay.min must be <= delay.max"))
+		])),
+		arrayMin: Schema.optionalKey(ArrayLengthSchema),
+		arrayMax: Schema.optionalKey(ArrayLengthSchema)
+	}).check(Schema.makeFilter(({ arrayMin, arrayMax }) => arrayMin === void 0 || arrayMax === void 0 || arrayMin <= arrayMax ? void 0 : "arrayMin must be <= arrayMax. Swap the values or remove one."))),
+	swr: Schema.optionalKey(HooksSchema),
+	"tanstack-query": Schema.optionalKey(HooksSchema),
+	"preact-query": Schema.optionalKey(HooksSchema),
+	"solid-query": Schema.optionalKey(HooksSchema),
+	"vue-query": Schema.optionalKey(HooksSchema),
+	"svelte-query": Schema.optionalKey(HooksSchema),
+	"angular-query": Schema.optionalKey(HooksSchema)
+});
+const decodeConfig = Schema.decodeUnknownEffect(ConfigSchema);
+const formatIssue = SchemaIssue.makeFormatterStandardSchemaV1();
+/**
+* Validates an already-loaded config object.
+*
+* The first issue is reported as `<a.b.c>: <message>`: a config file is written by hand, so
+* naming the field that is wrong matters more than listing every consequence of it.
+*/
+function parseConfig(config) {
+	return decodeConfig(config).pipe(Effect.mapError((error) => {
+		const issue = formatIssue(error.issue).issues[0];
+		const path = (issue?.path ?? []).map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+		return new ConfigError({ message: `Invalid config: ${path === "" ? "" : `${path}: `}${issue?.message ?? ""}` });
+	}));
+}
+const reloads = { count: 0 };
+/**
+* Imports the config module, bypassing the loader cache when asked.
+*
+* Node busts its cache with a `?reload=n` query on the specifier. Bun — the runtime this
+* generator targets — resolves `file:///x.ts?reload=1` back to the module it already has, so the
+* query buys nothing there. What both honour is a path they have not seen, so a reload copies the
+* config next to itself and imports the copy.
+*
+* A sibling rather than a temp directory: the config's own imports are relative to where it sits,
+* and a copy anywhere else would fail to resolve them. The copy is removed however the import
+* ends, and its name carries the pid so two processes watching one project cannot collide.
+*/
+function importConfigModule(abs, reload) {
+	return Effect.gen(function* () {
+		const importModule = (specifier) => Effect.tryPromise({
+			try: () => import(specifier),
+			catch: (error) => new ConfigError({ message: error instanceof Error ? error.message : String(error) })
+		});
+		if (!reload) return yield* importModule(pathToFileURL(abs).href);
+		const fs = yield* FileSystem.FileSystem;
+		const copy = resolve(abs, "..", `.asphodelos.config.${String(process.pid)}.${String(reloads.count += 1)}.ts`);
+		yield* fs.copyFile(abs, copy).pipe(Effect.mapError((error) => new ConfigError({ message: `Config reload failed: ${error.message}` })));
+		return yield* importModule(pathToFileURL(copy).href).pipe(Effect.ensuring(fs.remove(copy, { force: true }).pipe(Effect.orElseSucceed(() => void 0))));
+	});
+}
+/**
+* Loads and validates a config file, resolved against the current directory.
+*
+* `reload` re-reads a config that has already been imported — what `--watch` needs after the file
+* changes, and nothing else should ask for, since every reload leaves another copy of the module
+* behind.
+*/
+function readConfig(configPath, reload = false) {
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const abs = resolve(process.cwd(), configPath ?? "asphodelos.config.ts");
+		if (!(yield* fs.exists(abs).pipe(Effect.catchTag("PlatformError", () => Effect.succeed(false))))) return yield* new ConfigError({
+			message: `Config not found: ${abs}`,
+			notFound: true
+		});
+		const mod = yield* importConfigModule(abs, reload);
+		if (typeof mod !== "object" || mod === null || !("default" in mod) || mod.default === void 0) return yield* new ConfigError({ message: "Config must export default object" });
+		return yield* parseConfig(mod.default);
+	});
+}
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { ConfigError, defineConfig, parseConfig, readConfig };

package/dist/openapi-B4aAnx4P.mjs

@@ -0,0 +1,40 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { Data, Effect } from "effect";
+import path from "node:path";
+import SwaggerParser from "@apidevtools/swagger-parser";
+import { NodeHost, compile } from "@typespec/compiler";
+import { getOpenAPI3 } from "@typespec/openapi3";
+//#region src/openapi/index.ts
+var openapi_exports = /* @__PURE__ */ __exportAll({
+	OpenAPIError: () => OpenAPIError,
+	parseOpenAPI: () => parseOpenAPI,
+	pathEntries: () => pathEntries
+});
+/** The document could not be read, compiled or parsed into an OpenAPI object. */
+var OpenAPIError = class extends Data.TaggedError("OpenAPIError") {};
+/** Compiles a TypeSpec entry point into the plain document `SwaggerParser` expects. */
+async function readTypeSpec(input) {
+	const program = await compile(NodeHost, path.resolve(input), { noEmit: true });
+	if (program.diagnostics.length > 0) throw new Error(`TypeSpec compile failed:\n${program.diagnostics.map((d) => d.message).join("\n")}`);
+	const [record] = await getOpenAPI3(program);
+	const tsp = record && ("document" in record ? record.document : record.versions[0]?.document);
+	return JSON.parse(JSON.stringify(tsp));
+}
+/** Parses `input` into an OpenAPI document. */
+function parseOpenAPI(input) {
+	return Effect.tryPromise({
+		try: async () => await SwaggerParser.bundle(input.endsWith(".tsp") ? await readTypeSpec(input) : input),
+		catch: (error) => new OpenAPIError({ message: error instanceof Error ? error.message : String(error) })
+	});
+}
+/**
+* `Object.entries(openAPI.paths)` on its own yields `any` values: swagger-parser types the
+* document as a union of the OpenAPI 2 / 3.0 / 3.1 shapes, and inference over that union drops
+* the value type. Going through the annotation below is what keeps every caller on `PathItem`.
+*/
+function pathEntries(openAPI) {
+	const paths = openAPI.paths;
+	return Object.entries(paths);
+}
+//#endregion
+export { parseOpenAPI as n, pathEntries as r, openapi_exports as t };

package/dist/rolldown-runtime-wcPFST8Q.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/shared-CrbXsFUJ.mjs

@@ -0,0 +1,221 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import { S as unlink, _ as responses, a as hooks, c as mediaTypes, d as links, f as securitySchemes, g as parameters, h as examples, i as mock, l as pathItems, m as requestBodies, n as types, o as elysia, p as headers, r as test, s as eden, u as callbacks, v as schemas, x as readdir, y as components } from "./core-DS3sAabb.mjs";
+import { Effect } from "effect";
+import path, { posix } from "node:path";
+//#region src/shared/index.ts
+var shared_exports = /* @__PURE__ */ __exportAll({
+	cleanSplitOutputs: () => cleanSplitOutputs,
+	isUserCodeJob: () => isUserCodeJob,
+	jobTargets: () => jobTargets,
+	makeJob: () => makeJob
+});
+function edenJob(openAPI, edenConfig, prefix) {
+	return {
+		name: "eden",
+		output: edenConfig.output,
+		split: false,
+		run: (output) => eden(openAPI, output, edenConfig.import, edenConfig.client, prefix, edenConfig.docs)
+	};
+}
+function makeJob(openAPI, config) {
+	const baseDir = posix.normalize(posix.dirname(config.output ?? "src/index.ts"));
+	const { output: componentsOutput, ...componentTargets } = config.components ?? {};
+	const componentJobs = componentsOutput ? [{
+		name: "components",
+		output: componentsOutput,
+		split: false,
+		run: (output) => components(openAPI.components, output, config.readonly)
+	}] : perTypeComponentJobs(openAPI, componentTargets, baseDir, config.readonly);
+	return [
+		{
+			name: "elysia",
+			output: config.output ?? "src/index.ts",
+			split: false,
+			run: (output) => elysia(openAPI, {
+				output,
+				prefix: config.prefix,
+				port: config.port,
+				integration: config.integration === true,
+				readonly: config.readonly === true,
+				pathAlias: config.pathAlias === true ? `@/${baseDir.replace(/^\.?\/?/u, "")}` : void 0,
+				components: componentTargets,
+				componentsOutput
+			})
+		},
+		...componentJobs,
+		config.eden ? edenJob(openAPI, config.eden, config.prefix) : void 0,
+		config.types ? {
+			name: "types",
+			output: config.types.output,
+			split: false,
+			run: (output) => types(openAPI, output, config.prefix)
+		} : void 0,
+		config.test ? {
+			name: "test",
+			output: config.test.split ? `${baseDir}/modules` : config.test.output,
+			split: config.test.split,
+			run: (output) => test(openAPI, config.test?.split === true ? void 0 : output, {
+				appOutput: config.output ?? "src/index.ts",
+				split: config.test?.split === true,
+				pathAlias: config.test?.pathAlias,
+				prefix: config.prefix
+			})
+		} : void 0,
+		config.mock ? {
+			name: "mock",
+			output: config.mock.output,
+			split: false,
+			run: (output) => mock(openAPI, output, {
+				...config.mock,
+				prefix: config.prefix,
+				port: config.port
+			})
+		} : void 0,
+		...[
+			"swr",
+			"tanstack-query",
+			"preact-query",
+			"vue-query",
+			"svelte-query",
+			"solid-query",
+			"angular-query"
+		].map((library) => {
+			const cfg = config[library];
+			return cfg ? {
+				name: library,
+				output: cfg.output,
+				split: cfg.split,
+				run: (output) => hooks(openAPI, output, cfg.import, library, {
+					client: cfg.client,
+					basePath: config.prefix,
+					split: cfg.split
+				})
+			} : void 0;
+		})
+	].filter((job) => job !== void 0);
+}
+function perTypeComponentJobs(openAPI, componentTargets, baseDir, readonly) {
+	return [
+		openAPI.components?.schemas ? {
+			name: "schemas",
+			output: componentTargets.schemas?.output ?? `${baseDir}/components/schemas.ts`,
+			split: componentTargets.schemas?.split ?? false,
+			run: (output) => schemas(openAPI.components?.schemas, output, componentTargets.schemas?.split ?? false, componentTargets.schemas?.exportTypes ?? false, componentTargets, readonly)
+		} : void 0,
+		openAPI.components?.responses ? {
+			name: "responses",
+			output: componentTargets.responses?.output ?? `${baseDir}/components/responses.ts`,
+			split: componentTargets.responses?.split ?? false,
+			run: (output) => responses(openAPI.components?.responses, output, componentTargets.responses?.split ?? false, componentTargets.responses?.exportTypes ?? false, componentTargets, readonly)
+		} : void 0,
+		openAPI.components?.parameters ? {
+			name: "parameters",
+			output: componentTargets.parameters?.output ?? `${baseDir}/components/parameters.ts`,
+			split: componentTargets.parameters?.split ?? false,
+			run: (output) => parameters(openAPI.components?.parameters, output, componentTargets.parameters?.split ?? false, componentTargets.parameters?.exportTypes ?? false, componentTargets, readonly)
+		} : void 0,
+		openAPI.components?.examples ? {
+			name: "examples",
+			output: componentTargets.examples?.output ?? `${baseDir}/components/examples.ts`,
+			split: componentTargets.examples?.split ?? false,
+			run: (output) => examples(openAPI.components?.examples, output, componentTargets.examples?.split ?? false, componentTargets)
+		} : void 0,
+		openAPI.components?.requestBodies ? {
+			name: "requestBodies",
+			output: componentTargets.requestBodies?.output ?? `${baseDir}/components/requestBodies.ts`,
+			split: componentTargets.requestBodies?.split ?? false,
+			run: (output) => requestBodies(openAPI.components?.requestBodies, output, componentTargets.requestBodies?.split ?? false, componentTargets.requestBodies?.exportTypes ?? false, componentTargets, readonly)
+		} : void 0,
+		openAPI.components?.headers ? {
+			name: "headers",
+			output: componentTargets.headers?.output ?? `${baseDir}/components/headers.ts`,
+			split: componentTargets.headers?.split ?? false,
+			run: (output) => headers(openAPI.components?.headers, output, componentTargets.headers?.split ?? false, componentTargets.headers?.exportTypes ?? false, componentTargets, readonly)
+		} : void 0,
+		openAPI.components?.securitySchemes ? {
+			name: "securitySchemes",
+			output: componentTargets.securitySchemes?.output ?? `${baseDir}/components/securitySchemes.ts`,
+			split: componentTargets.securitySchemes?.split ?? false,
+			run: (output) => securitySchemes(openAPI.components?.securitySchemes, output, componentTargets.securitySchemes?.split ?? false, componentTargets)
+		} : void 0,
+		openAPI.components?.links ? {
+			name: "links",
+			output: componentTargets.links?.output ?? `${baseDir}/components/links.ts`,
+			split: componentTargets.links?.split ?? false,
+			run: (output) => links(openAPI.components?.links, output, componentTargets.links?.split ?? false, componentTargets)
+		} : void 0,
+		openAPI.components?.callbacks ? {
+			name: "callbacks",
+			output: componentTargets.callbacks?.output ?? `${baseDir}/components/callbacks.ts`,
+			split: componentTargets.callbacks?.split ?? false,
+			run: (output) => callbacks(openAPI.components?.callbacks, output, componentTargets.callbacks?.split ?? false, componentTargets)
+		} : void 0,
+		openAPI.components?.pathItems ? {
+			name: "pathItems",
+			output: componentTargets.pathItems?.output ?? `${baseDir}/components/pathItems.ts`,
+			split: componentTargets.pathItems?.split ?? false,
+			run: (output) => pathItems(openAPI.components?.pathItems, output, componentTargets.pathItems?.split ?? false, componentTargets)
+		} : void 0,
+		openAPI.components?.mediaTypes ? {
+			name: "mediaTypes",
+			output: componentTargets.mediaTypes?.output ?? `${baseDir}/components/mediaTypes.ts`,
+			split: componentTargets.mediaTypes?.split ?? false,
+			run: (output) => mediaTypes(openAPI.components?.mediaTypes, output, componentTargets.mediaTypes?.split ?? false, componentTargets.mediaTypes?.exportTypes ?? false, componentTargets, readonly)
+		} : void 0
+	];
+}
+/**
+* Generators that merge into what is already at their output rather than overwrite it.
+*
+* `elysia` and `test` read the file back and keep whatever the user wrote there (`mergeSource`),
+* so what they write holds the user's code as much as the generator's. Nothing that deletes — the
+* split clean below, the Vite plugin's stale-output cleanup — may touch one.
+*/
+const USER_CODE_JOBS = new Set(["elysia", "test"]);
+function isUserCodeJob(job) {
+	return USER_CODE_JOBS.has(job.name);
+}
+/**
+* Every absolute path a job writes under.
+*
+* The output itself, and for `elysia` the `modules/` directory it fills beside the app entry —
+* one file per resource, which a caller that watches for changed output has to see as well.
+*/
+function jobTargets(job) {
+	const output = path.resolve(process.cwd(), job.output);
+	return job.name === "elysia" ? [output, path.join(path.dirname(output), "modules")] : [output];
+}
+function cleanSplitDirectory(directory, keep) {
+	return Effect.gen(function* () {
+		const stale = (yield* readdir(directory)).filter((name) => name.endsWith(".ts")).map((name) => path.join(directory, name)).filter((file) => !keep.has(file));
+		yield* Effect.all(stale.map(unlink), { concurrency: "unbounded" });
+		return stale;
+	});
+}
+/**
+* Empties every split output directory before the generators refill them, answering with what
+* was removed.
+*
+* A split generator writes one file per entry plus a barrel beside them, and knows only what it
+* writes — so an entry that leaves the document leaves its file behind, orphaned and still
+* importing names the document no longer defines. A split directory is therefore the generator's,
+* not a place to keep anything by hand.
+*
+* Only the direct `.ts` children are removed, never a subdirectory, and never a file another job
+* writes on its own: a single-file output that lives inside a split directory is left where it is
+* rather than deleted and rewritten. A split job that merges into the user's code is never
+* cleaned at all.
+*
+* This runs before any job writes, never per job as it goes: two jobs can be aimed at one
+* directory, and a clean that lands after a sibling has filled it would take the fresh files with
+* it.
+*/
+function cleanSplitOutputs(jobs) {
+	return Effect.gen(function* () {
+		const keep = new Set(jobs.filter((job) => !job.split).map((job) => path.resolve(process.cwd(), job.output)));
+		const directories = new Set(jobs.filter((job) => job.split && !isUserCodeJob(job)).map((job) => path.resolve(process.cwd(), job.output)));
+		return (yield* Effect.all([...directories].map((directory) => cleanSplitDirectory(directory, keep)), { concurrency: "unbounded" })).flat();
+	});
+}
+//#endregion
+export { shared_exports as a, makeJob as i, isUserCodeJob as n, jobTargets as r, cleanSplitOutputs as t };

package/dist/vite-plugin/index.d.mts

@@ -0,0 +1,11 @@
+//#region src/vite-plugin/index.d.ts
+/**
+ * The Vite plugin: regenerates on every change to `asphodelos.config.ts` or to the documents it
+ * names, and reloads the browser when the output actually changed.
+ *
+ * Every pass — the first one, a config edit, a document edit — goes through one queue, so no two
+ * passes ever interleave their cleanup with each other's writes.
+ */
+declare function asphodelosVite(): any;
+//#endregion
+export { asphodelosVite };