typeflake 0.0.1-alpha.0

package/dist/options-CE3YO7EL.mjs

@@ -0,0 +1,760 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Data from "effect/Data";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import * as Clock from "effect/Clock";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/errors.ts
+var FlakeImportError = class extends Data.TaggedError("FlakeImportError") {};
+var NixCheckFailed = class extends Data.TaggedError("NixCheckFailed") {};
+var TypeScriptCheckFailed = class extends Data.TaggedError("TypeScriptCheckFailed") {};
+var DoctorFailed = class extends Data.TaggedError("DoctorFailed") {};
+var OptionMetadataParseError = class extends Data.TaggedError("OptionMetadataParseError") {};
+var UnsupportedOptionsFound = class extends Data.TaggedError("UnsupportedOptionsFound") {};
+//#endregion
+//#region src/process.ts
+const runCommandExitCode = (options) => Effect.gen(function* () {
+	const process = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const command = ChildProcess.make(options.command, options.args, {
+		stderr: options.stderr ?? "ignore",
+		stdin: options.stdin ?? "ignore",
+		stdout: options.stdout ?? "ignore"
+	});
+	const exitCode = yield* process.exitCode(command);
+	return Number(exitCode);
+});
+const runCommandString = (options) => Effect.gen(function* () {
+	const process = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const command = ChildProcess.make(options.command, options.args, { stdin: options.stdin ?? "ignore" });
+	return yield* process.string(command, { includeStderr: options.stderr === "inherit" });
+});
+//#endregion
+//#region src/nix/expr.ts
+const nixValueSymbol = Symbol("typeflake.nixValue");
+const rawNix = (code) => ({
+	[nixValueSymbol]: true,
+	tag: "raw",
+	kind: "raw",
+	code
+});
+const nixExpr = (kind, code) => ({
+	[nixValueSymbol]: true,
+	tag: "raw",
+	kind,
+	code
+});
+const nixAttrPath = (kind, parts) => ({
+	[nixValueSymbol]: true,
+	tag: "raw",
+	kind,
+	code: parts.map(renderAttrPathSegment).join(".")
+});
+const nixString = (value) => ({
+	[nixValueSymbol]: true,
+	tag: "string",
+	value
+});
+const nixNumber = (value) => ({
+	[nixValueSymbol]: true,
+	tag: "number",
+	value
+});
+const nixBoolean = (value) => ({
+	[nixValueSymbol]: true,
+	tag: "boolean",
+	value
+});
+const nixNull = {
+	[nixValueSymbol]: true,
+	tag: "null"
+};
+const nixList = (items) => ({
+	[nixValueSymbol]: true,
+	tag: "list",
+	items: items.map(normalizeNixInput)
+});
+const nixAttrSet = (attrs) => ({
+	[nixValueSymbol]: true,
+	tag: "attrset",
+	attrs: Object.fromEntries(Object.entries(attrs).map(([key, value]) => [key, value === void 0 ? void 0 : normalizeNixInput(value)]))
+});
+const normalizeNixInput = (value) => {
+	if (isNixValue(value)) return value;
+	switch (typeof value) {
+		case "string": return nixString(value);
+		case "number": return nixNumber(value);
+		case "boolean": return nixBoolean(value);
+		case "object":
+			if (value === null) return nixNull;
+			if (isReadonlyArray(value)) return nixList(value);
+			return nixAttrSet(value);
+		case "undefined":
+		case "bigint":
+		case "function":
+		case "symbol": throw new Error(`Cannot normalize ${typeof value} as Nix`);
+	}
+	throw new Error(`Cannot normalize unsupported value as Nix: ${String(value)}`);
+};
+const renderAttrName = (name) => /^[A-Za-z_][A-Za-z0-9_'-]*$/.test(name) ? name : JSON.stringify(name);
+const renderAttrPathSegment = renderAttrName;
+const isNixValue = (value) => typeof value === "object" && value !== null && nixValueSymbol in value && value[nixValueSymbol] === true && "tag" in value && (value.tag === "raw" || value.tag === "string" || value.tag === "number" || value.tag === "boolean" || value.tag === "null" || value.tag === "list" || value.tag === "attrset");
+const isReadonlyArray = (value) => Array.isArray(value);
+//#endregion
+//#region src/nix/render.ts
+const renderNixValue = (value, options = {}) => renderValue(normalizeNixInput(value), options.indent ?? 0);
+const renderValue = (value, indent) => {
+	switch (value.tag) {
+		case "raw": return indentRaw(value.code, indent);
+		case "string": return JSON.stringify(value.value);
+		case "number":
+			if (!Number.isFinite(value.value)) throw new Error(`Cannot render non-finite number as Nix: ${value.value}`);
+			return String(value.value);
+		case "boolean": return value.value ? "true" : "false";
+		case "null": return "null";
+		case "list": return renderList(value.items, indent);
+		case "attrset": return renderAttrSet(value.attrs, indent);
+	}
+	return absurd(value);
+};
+const renderList = (items, indent) => {
+	const normalized = items.map(normalizeNixInput);
+	if (normalized.length === 0) return "[]";
+	const childIndent = indent + 1;
+	const pad = indentation$1(indent);
+	const childPad = indentation$1(childIndent);
+	return `[\n${normalized.map((item) => `${childPad}${renderValue(item, childIndent)}`).join("\n")}\n${pad}]`;
+};
+const renderAttrSet = (attrs, indent) => {
+	const entries = Object.entries(attrs).filter((entry) => entry[1] !== void 0);
+	if (entries.length === 0) return "{}";
+	const childIndent = indent + 1;
+	const pad = indentation$1(indent);
+	const childPad = indentation$1(childIndent);
+	return `{\n${entries.toSorted(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${childPad}${renderAttrName(key)} = ${renderValue(normalizeNixInput(value), childIndent)};`).join("\n")}\n${pad}}`;
+};
+const indentation$1 = (level) => "  ".repeat(level);
+const indentRaw = (code, indent) => {
+	const lines = code.split("\n");
+	if (lines.length === 1) return code;
+	const pad = indentation$1(indent);
+	const [first, ...rest] = lines;
+	return [first, ...rest.map((line) => line.length === 0 ? line : `${pad}${line}`)].join("\n");
+};
+const absurd = (value) => {
+	throw new Error(`Unexpected Nix expression: ${String(value)}`);
+};
+//#endregion
+//#region src/flake.ts
+const Flake = {
+	input(name, url) {
+		return {
+			...nixExpr("input", renderAttrName(name)),
+			name,
+			url
+		};
+	},
+	inputs(inputs) {
+		return inputs;
+	},
+	make(spec) {
+		return {
+			taint: "pure",
+			spec: Effect.succeed(spec)
+		};
+	},
+	effect(spec) {
+		return {
+			spec,
+			taint: "effect"
+		};
+	},
+	impure(spec) {
+		return {
+			spec,
+			taint: "impure"
+		};
+	}
+};
+const resolveFlakeSpec = (flake) => flake.spec;
+const renderFlake = (spec) => {
+	const outputs = spec.outputs(spec.inputs);
+	return `${renderNixValue({
+		description: spec.description ?? "Generated by Typeflake",
+		inputs: renderInputs(spec.inputs),
+		outputs: rawNix(renderOutputs(spec.inputs, outputs))
+	})}\n`;
+};
+const renderInputs = (inputs) => Object.fromEntries(Object.entries(inputs).map(([name, input]) => [name, { url: input.url }]));
+const renderOutputs = (inputs, outputs) => {
+	return `{ ${["self", ...Object.keys(inputs)].join(", ")} }: ${renderNixValue({
+		devShells: outputs.devShells === void 0 ? void 0 : renderDevShells(outputs.devShells),
+		nixosConfigurations: outputs.nixosConfigurations
+	})}`;
+};
+const renderDevShells = (systems) => Object.fromEntries(Object.entries(systems).map(([system, shells]) => [system, Object.fromEntries(Object.entries(shells).map(([name, shell]) => [name, rawNix(`let pkgs = nixpkgs.legacyPackages.${renderAttrName(system)}; in pkgs.mkShell ${renderNixValue({ packages: shell.packages ?? [] })}`)]))]));
+//#endregion
+//#region src/tooling.ts
+const effectTsgoCommand = () => resolvePackageBin("@effect/tsgo/package.json", "dist/effect-tsgo.js");
+const tsgoCommand = () => resolvePackageBin("@typescript/native-preview/package.json", "bin/tsgo");
+const resolvePackageBin = (packageJsonSpecifier, binPath) => {
+	return join(dirname(fileURLToPath(import.meta.resolve(packageJsonSpecifier))), binPath);
+};
+//#endregion
+//#region src/sync.ts
+const sync = (options) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const inputPath = path.resolve(options.input);
+	const outputPath = path.resolve(options.output);
+	const moduleUrl = yield* path.toFileUrl(inputPath);
+	yield* runTypeScriptCheck("tsconfig.json");
+	const rendered = renderFlake(yield* resolveFlakeSpec((yield* loadFlakeModule(moduleUrl)).default));
+	yield* fs.makeDirectory(path.dirname(outputPath), { recursive: true });
+	yield* fs.writeFileString(outputPath, rendered);
+});
+const loadFlakeModule = (moduleUrl) => Effect.gen(function* () {
+	const cacheBust = yield* Clock.currentTimeMillis;
+	const specifier = `${moduleUrl.href}?typeflake=${cacheBust}`;
+	return yield* Effect.tryPromise({
+		try: () => importFlakeModule(specifier),
+		catch: (cause) => new FlakeImportError({
+			cause,
+			specifier
+		})
+	});
+});
+const importFlakeModule = (specifier) => import(specifier);
+const runTypeScriptCheck = (project) => Effect.gen(function* () {
+	const exitCode = yield* runCommandExitCode({
+		args: [
+			"--noEmit",
+			"--project",
+			project
+		],
+		command: tsgoCommand(),
+		stderr: "inherit",
+		stdin: "inherit",
+		stdout: "inherit"
+	});
+	if (exitCode !== 0) return yield* new TypeScriptCheckFailed({
+		exitCode,
+		project
+	});
+});
+//#endregion
+//#region src/check.ts
+const check = (options) => Effect.gen(function* () {
+	yield* sync(options);
+	const target = yield* prepareFlakeTarget(options.output);
+	yield* runNixFlakeCheck(target, options.noBuild ?? true);
+});
+const prepareFlakeTarget = (output) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const outputPath = path.resolve(output);
+	if (path.basename(outputPath) === "flake.nix") return path.dirname(outputPath);
+	const directory = yield* fs.makeTempDirectory({ prefix: "typeflake-check-" });
+	yield* fs.copyFile(outputPath, path.join(directory, "flake.nix"));
+	return directory;
+});
+const runNixFlakeCheck = (target, noBuild) => Effect.gen(function* () {
+	const exitCode = yield* runCommandExitCode({
+		args: noBuild ? [
+			"flake",
+			"check",
+			"--no-build",
+			target
+		] : [
+			"flake",
+			"check",
+			target
+		],
+		command: "nix",
+		stderr: "inherit",
+		stdin: "inherit",
+		stdout: "inherit"
+	});
+	if (exitCode !== 0) return yield* new NixCheckFailed({
+		exitCode,
+		target
+	});
+});
+//#endregion
+//#region src/doctor.ts
+const doctor = (options = {}) => Effect.gen(function* () {
+	const project = options.project ?? "tsconfig.json";
+	const checks = yield* Effect.all([
+		checkCommand("Nix", "nix", ["--version"]),
+		checkCommand("Node", "node", ["--version"]),
+		checkCommand("TypeScript-Go", tsgoCommand(), ["--version"]),
+		checkCommand("Effect TSGO", effectTsgoCommand(), ["get-exe-path"]),
+		checkCommand("Project TypeScript", tsgoCommand(), [
+			"--noEmit",
+			"--project",
+			project
+		])
+	], { concurrency: "unbounded" });
+	return {
+		checks,
+		ok: checks.every((check) => check.ok)
+	};
+});
+const renderDoctorReport = (report) => ["Typeflake doctor", ...report.checks.map((check) => `${check.ok ? "OK" : "FAIL"} ${check.name}: ${check.detail}`)].join("\n");
+const checkCommand = (name, command, args) => runCommandExitCode({
+	args,
+	command
+}).pipe(Effect.match({
+	onFailure: (cause) => ({
+		detail: String(cause),
+		name,
+		ok: false
+	}),
+	onSuccess: (exitCode) => ({
+		detail: exitCode === 0 ? `${command} ${args.join(" ")}` : `exit code ${exitCode}`,
+		name,
+		ok: exitCode === 0
+	})
+}));
+//#endregion
+//#region src/options/generate.ts
+const generateOptionTypes = (options) => {
+	const body = renderRootInterface(options.rootTypeName, options.scope, options.options);
+	return `${renderGeneratedHeader()}
+import type { NixExpr, NixInput } from ${JSON.stringify(options.importPath)};
+
+${renderSharedTypes()}
+
+${body}
+`;
+};
+const generateOptionTypeFile = (options) => {
+	const interfaces = options.roots.map((root) => renderRootInterface(root.rootTypeName, root.scope, options.options)).join("\n\n");
+	return `${renderGeneratedHeader(options.fixtureScope)}
+import type { NixExpr, NixInput } from ${JSON.stringify(options.importPath)};
+
+${renderSharedTypes()}
+
+${interfaces}
+`;
+};
+const renderRootInterface = (rootTypeName, scope, options) => {
+	const tree = buildOptionTree(options.filter((option) => option.scope === scope).map((option) => option));
+	return `export interface ${rootTypeName} ${renderTree(tree, 0)}`;
+};
+const renderGeneratedHeader = (fixtureScope) => {
+	const lines = ["// Generated by Typeflake from real Nix option metadata."];
+	if (fixtureScope !== void 0) lines.push(`// Fixture scope: ${fixtureScope}`);
+	return lines.join("\n");
+};
+const renderSharedTypes = () => `export type NixOptionValue<T> = T | NixExpr;
+
+export type UnsupportedNixOption<Description extends string> = NixExpr<"unsupported"> & {
+  readonly __unsupportedNixOption: Description;
+};`;
+const buildOptionTree = (options) => {
+	const root = createTree();
+	for (const option of options) insertOption(root, option.path, option);
+	return root;
+};
+const createTree = () => ({ children: /* @__PURE__ */ new Map() });
+const insertOption = (root, path, option) => {
+	let current = root;
+	for (const segment of path) {
+		const existing = current.children.get(segment);
+		if (existing !== void 0) current = existing;
+		else {
+			const next = createTree();
+			current.children.set(segment, next);
+			current = next;
+		}
+	}
+	current.option = option;
+};
+const renderTree = (tree, depth) => {
+	const entries = [...tree.children.entries()].toSorted(([left], [right]) => left.localeCompare(right));
+	if (entries.length === 0) return tree.option === void 0 ? "{}" : toOptionValueType(tree.option);
+	const pad = indentation(depth);
+	const childPad = indentation(depth + 1);
+	return `{\n${entries.map(([key, child]) => `${childPad}readonly ${quoteProperty(key)}?: ${renderTree(child, depth + 1)};`).join("\n")}\n${pad}}`;
+};
+const toOptionValueType = (option) => `NixOptionValue<${toTypeScriptType(option.type, option.path)}>`;
+const toTypeScriptType = (nixType, path = []) => {
+	const normalized = normalizeTypeName(nixType.name);
+	const description = nixType.description?.toLowerCase() ?? "";
+	if (normalized === "bool" || normalized === "boolean") return "boolean";
+	if (normalized === "nullor") return renderNullableType(nixType, path);
+	if (normalized === "listof") return renderListType(nixType, path);
+	if (normalized === "attrsof") return renderAttrsType(nixType, path);
+	if (normalized === "str" || normalized === "string" || normalized === "enum" || normalized.startsWith("strmatching")) return "string";
+	if (isNumberType(normalized, description)) return "number";
+	if (normalized === "package") return "NixInput";
+	if (normalized === "path") return "string";
+	if (normalized === "submodule") return "NixInput";
+	if (description.includes("list of package")) return "readonly NixInput[]";
+	if (description.includes("list of string")) return "readonly string[]";
+	if (description.includes("attribute set")) return "Readonly<Record<string, NixInput>>";
+	return unsupportedType(nixType);
+};
+const collectUnsupportedOptions = (options) => options.filter((option) => toTypeScriptType(option.type, option.path).startsWith("Unsupported"));
+const renderNullableType = (nixType, path) => {
+	const nested = nixType.nestedTypes.elemType ?? nixType.nestedTypes.valueType;
+	if (nested === void 0) return `${unsupportedType(nixType)} | null`;
+	return `${toTypeScriptType(nested, path)} | null`;
+};
+const renderListType = (nixType, path) => {
+	const elemType = nixType.nestedTypes.elemType;
+	if (elemType === void 0) return "readonly NixInput[]";
+	return `readonly ${toCollectionElementType(elemType, path)}[]`;
+};
+const renderAttrsType = (nixType, path) => {
+	const elemType = nixType.nestedTypes.elemType;
+	if (elemType === void 0) return "Readonly<Record<string, NixInput>>";
+	return `Readonly<Record<string, ${toCollectionElementType(elemType, path)}>>`;
+};
+const toCollectionElementType = (nixType, path) => {
+	if (normalizeTypeName(nixType.name) === "submodule") return "NixInput";
+	return toTypeScriptType(nixType, path);
+};
+const isNumberType = (normalized, description) => normalized.includes("int") || normalized === "number" || description.includes("integer") || description.includes("signed integer");
+const unsupportedType = (nixType) => `UnsupportedNixOption<${JSON.stringify(renderUnsupportedDescription(nixType))}>`;
+const renderUnsupportedDescription = (nixType) => nixType.description === null ? nixType.name : `${nixType.name}: ${nixType.description}`;
+const normalizeTypeName = (name) => name.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+const quoteProperty = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+const indentation = (depth) => "  ".repeat(depth);
+//#endregion
+//#region src/options/probe.ts
+const defaultNixOSOptionPaths = [
+	[
+		"boot",
+		"loader",
+		"grub",
+		"devices"
+	],
+	["environment", "systemPackages"],
+	["fileSystems"],
+	[
+		"networking",
+		"firewall",
+		"allowedTCPPorts"
+	],
+	["networking", "hostName"],
+	[
+		"services",
+		"nginx",
+		"enable"
+	],
+	[
+		"services",
+		"openssh",
+		"enable"
+	],
+	[
+		"services",
+		"openssh",
+		"ports"
+	],
+	["system", "stateVersion"],
+	["users", "users"]
+];
+const defaultHomeManagerOptionPaths = [
+	["home", "stateVersion"],
+	["home", "packages"],
+	[
+		"programs",
+		"git",
+		"enable"
+	]
+];
+const renderOptionProbeExpression = (options) => {
+	const nixosPaths = options.nixosOptions?.optionPaths ?? [];
+	const homeManagerPaths = options.homeManagerOptions?.optionPaths ?? [];
+	return `let
+  nixpkgs = ${options.nixpkgs.code};
+  system = ${renderNixValue(options.system)};
+  nixpkgsPath = nixpkgs.outPath or nixpkgs;
+  pkgs = import nixpkgsPath { inherit system; };
+
+  renderDoc = value:
+    if value == null then null
+    else if builtins.isString value then value
+    else if builtins.isAttrs value && value ? text then value.text
+    else builtins.toJSON value;
+
+  getPath = options: path:
+    builtins.foldl' (value: key: value.\${key}) options path;
+
+  typeToIR = type: {
+    name = type.name or "unknown";
+    description = renderDoc (type.description or null);
+    nestedTypes = builtins.mapAttrs (_: nestedType: typeToIR nestedType) (type.nestedTypes or {});
+  };
+
+  optionToIR = scope: options: path:
+    let option = getPath options path; in {
+      inherit path scope;
+      declarations = map toString (option.declarations or []);
+      defaultText = renderDoc (option.defaultText or null);
+      description = renderDoc (option.description or null);
+      exampleText = renderDoc (option.example or null);
+      internal = option.internal or false;
+      readOnly = option.readOnly or false;
+      type = typeToIR option.type;
+      visible = option.visible or true;
+    };
+
+  nixosEval = import "\${nixpkgsPath}/nixos/lib/eval-config.nix" {
+    inherit system;
+    modules = [];
+  };
+${renderHomeManagerBinding(options)}
+in {
+  nixos = map (optionToIR "nixos" nixosEval.options) ${renderPathList(nixosPaths)};
+  homeManager = ${renderHomeManagerOptions(options, homeManagerPaths)};
+}`;
+};
+const flakeInput = (name) => nixExpr("flakeInput", `(builtins.getFlake ("git+file://" + toString ./.))
+    .inputs.${name}`);
+const projectFlakeInput = (flakeReference, name) => nixExpr("flakeInput", `(builtins.getFlake ${renderNixValue(flakeReference)})
+    .inputs.${name}`);
+const renderPathList = (paths) => renderNixValue(paths);
+const renderHomeManagerBinding = (options) => {
+	if (options.homeManager === void 0) return "";
+	return `  homeManager = ${options.homeManager.code};
+  homeManagerEval = homeManager.lib.homeManagerConfiguration {
+    inherit pkgs;
+    modules = [{
+      home.homeDirectory = "/home/typeflake";
+      home.stateVersion = "25.11";
+      home.username = "typeflake";
+    }];
+  };
+`;
+};
+const renderHomeManagerOptions = (options, paths) => {
+	if (options.homeManager === void 0) return "[]";
+	return `map (optionToIR "home-manager" homeManagerEval.options) ${renderPathList(paths)}`;
+};
+//#endregion
+//#region src/options/document.ts
+const makeOptionMetadataDocument = (source, payload) => ({
+	options: sortOptions([...payload.nixos, ...payload.homeManager]),
+	source: {
+		flake: source.flake,
+		homeManagerInput: source.homeManagerInput,
+		nixpkgsInput: source.nixpkgsInput,
+		scopes: sortScopes(source.scopes),
+		system: source.system
+	},
+	version: 1
+});
+const optionMetadataDocumentToJson = (document) => `${JSON.stringify(document, null, 2)}\n`;
+const parseOptionMetadataDocument = (value) => {
+	const record = requireRecord(value, "Option metadata document");
+	const version = record.version;
+	if (version !== 1) throw new Error(`Unsupported option metadata version: ${String(version)}`);
+	return {
+		options: requireArray(record.options, "options").map(parseOptionIR),
+		source: parseSource(record.source),
+		version
+	};
+};
+const parseOptionProbePayload = (value) => {
+	const record = requireRecord(value, "Option probe payload");
+	return {
+		homeManager: requireArray(record.homeManager, "homeManager").map(parseOptionIR),
+		nixos: requireArray(record.nixos, "nixos").map(parseOptionIR)
+	};
+};
+const parseSource = (value) => {
+	const record = requireRecord(value, "source");
+	return {
+		flake: requireString(record.flake, "source.flake"),
+		homeManagerInput: record.homeManagerInput === null ? null : requireString(record.homeManagerInput, "source.homeManagerInput"),
+		nixpkgsInput: requireString(record.nixpkgsInput, "source.nixpkgsInput"),
+		scopes: requireArray(record.scopes, "source.scopes").map(parseScope),
+		system: requireString(record.system, "source.system")
+	};
+};
+const parseOptionIR = (value) => {
+	const record = requireRecord(value, "option");
+	return {
+		declarations: requireArray(record.declarations, "option.declarations").map((item) => requireString(item, "option.declarations[]")),
+		defaultText: requireNullableString(record.defaultText, "option.defaultText"),
+		description: requireNullableString(record.description, "option.description"),
+		exampleText: requireNullableString(record.exampleText, "option.exampleText"),
+		internal: requireBoolean(record.internal, "option.internal"),
+		path: parsePath(record.path),
+		readOnly: requireBoolean(record.readOnly, "option.readOnly"),
+		scope: parseScope(record.scope),
+		type: parseType(record.type),
+		visible: parseVisible(record.visible)
+	};
+};
+const parseType = (value) => {
+	const record = requireRecord(value, "option.type");
+	const nestedTypes = requireRecord(record.nestedTypes, "option.type.nestedTypes");
+	return {
+		description: requireNullableString(record.description, "option.type.description"),
+		name: requireString(record.name, "option.type.name"),
+		nestedTypes: Object.fromEntries(Object.entries(nestedTypes).map(([key, nestedType]) => [key, parseType(nestedType)]))
+	};
+};
+const parsePath = (value) => {
+	const [first, ...rest] = requireArray(value, "option.path").map((item) => requireString(item, "option.path[]"));
+	if (first === void 0) throw new Error("Option paths must contain at least one segment");
+	return [first, ...rest];
+};
+const parseScope = (value) => {
+	switch (value) {
+		case "home-manager":
+		case "nixos": return value;
+		default: throw new Error(`Unexpected option scope: ${String(value)}`);
+	}
+};
+const parseVisible = (value) => {
+	if (value === true || value === false || value === "shallow") return value;
+	throw new Error(`Unexpected option visibility: ${String(value)}`);
+};
+const sortOptions = (options) => options.toSorted((left, right) => {
+	const scopeOrder = left.scope.localeCompare(right.scope);
+	if (scopeOrder !== 0) return scopeOrder;
+	return left.path.join(".").localeCompare(right.path.join("."));
+});
+const sortScopes = (scopes) => [...new Set(scopes)].toSorted((left, right) => left.localeCompare(right));
+const requireRecord = (value, name) => {
+	if (isRecord(value)) return value;
+	throw new Error(`${name} must be an object`);
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const requireArray = (value, name) => {
+	if (Array.isArray(value)) return value;
+	throw new Error(`${name} must be an array`);
+};
+const requireString = (value, name) => {
+	if (typeof value === "string") return value;
+	throw new Error(`${name} must be a string`);
+};
+const requireNullableString = (value, name) => {
+	if (value === null || typeof value === "string") return value;
+	throw new Error(`${name} must be a string or null`);
+};
+const requireBoolean = (value, name) => {
+	if (typeof value === "boolean") return value;
+	throw new Error(`${name} must be a boolean`);
+};
+//#endregion
+//#region src/options/commands.ts
+const defaultOptionScopes = ["nixos", "home-manager"];
+const probeProjectOptions = (options) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const flakeRoot = path.resolve(options.flake);
+	const flakeReference = yield* resolveFlakeReference(flakeRoot);
+	const scopes = normalizeScopes(options.scopes);
+	const includesNixOS = scopes.includes("nixos");
+	const includesHomeManager = scopes.includes("home-manager");
+	const output = yield* runCommandString({
+		args: [
+			"eval",
+			"--impure",
+			"--json",
+			"--expr",
+			renderOptionProbeExpression({
+				nixpkgs: projectFlakeInput(flakeReference, options.nixpkgsInput),
+				system: options.system,
+				...includesHomeManager ? {
+					homeManager: projectFlakeInput(flakeReference, options.homeManagerInput),
+					homeManagerOptions: { optionPaths: options.homeManagerOptionPaths ?? defaultHomeManagerOptionPaths }
+				} : {},
+				...includesNixOS ? { nixosOptions: { optionPaths: options.nixosOptionPaths ?? defaultNixOSOptionPaths } } : {}
+			})
+		],
+		command: "nix"
+	});
+	const payload = yield* parseProbeOutput(output);
+	const document = makeOptionMetadataDocument({
+		flake: flakeReference,
+		homeManagerInput: includesHomeManager ? options.homeManagerInput : null,
+		nixpkgsInput: options.nixpkgsInput,
+		scopes,
+		system: options.system
+	}, payload);
+	const outputPath = path.resolve(options.output);
+	yield* fs.makeDirectory(path.dirname(outputPath), { recursive: true });
+	yield* fs.writeFileString(outputPath, optionMetadataDocumentToJson(document));
+	return document;
+});
+const generateProjectOptionTypes = (options) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const inputPath = path.resolve(options.input);
+	const outputPath = path.resolve(options.output);
+	const document = yield* readOptionMetadataDocument(inputPath);
+	const unsupported = collectUnsupportedOptions(document.options);
+	if (options.strict === true && unsupported.length > 0) return yield* new UnsupportedOptionsFound({ options: unsupported.map((option) => `${option.scope}:${option.path.join(".")}`) });
+	yield* fs.makeDirectory(path.dirname(outputPath), { recursive: true });
+	yield* fs.writeFileString(outputPath, renderGeneratedOptions(document));
+	return {
+		document,
+		unsupported
+	};
+});
+const readOptionMetadataDocument = (inputPath) => Effect.gen(function* () {
+	const text = yield* (yield* FileSystem.FileSystem).readFileString(inputPath);
+	return yield* parseMetadataText(text, inputPath);
+});
+const renderGeneratedOptions = (document) => generateOptionTypeFile({
+	fixtureScope: `project-local ${document.source.scopes.join(" + ")} options from ${document.source.flake}.`,
+	importPath: "typeflake",
+	options: document.options,
+	roots: rootsForScopes(document.source.scopes)
+});
+const resolveFlakeReference = (flakeRoot) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const gitRoot = yield* findGitRoot(flakeRoot);
+	if (gitRoot === null) return `path:${flakeRoot}`;
+	const relative = path.relative(gitRoot, flakeRoot);
+	const base = `git+file://${gitRoot}`;
+	if (relative === "") return base;
+	return `${base}?dir=${encodeFlakeDir(relative, path.sep)}`;
+});
+const rootsForScopes = (scopes) => normalizeScopes(scopes).map((scope) => scope === "nixos" ? {
+	rootTypeName: "NixOSGeneratedConfig",
+	scope
+} : {
+	rootTypeName: "HomeManagerGeneratedConfig",
+	scope
+});
+const normalizeScopes = (scopes) => {
+	const normalized = [...new Set(scopes)];
+	return normalized.length === 0 ? defaultOptionScopes : normalized;
+};
+const findGitRoot = (start) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	let current = path.resolve(start);
+	while (true) {
+		if (yield* fs.exists(path.join(current, ".git"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+});
+const encodeFlakeDir = (relative, separator) => relative.split(separator).map(encodeURIComponent).join("/");
+const parseProbeOutput = (text) => Effect.try({
+	try: () => parseOptionProbePayload(JSON.parse(text)),
+	catch: (cause) => new OptionMetadataParseError({ cause })
+});
+const parseMetadataText = (text, path) => Effect.try({
+	try: () => parseOptionMetadataDocument(JSON.parse(text)),
+	catch: (cause) => new OptionMetadataParseError({
+		cause,
+		path
+	})
+});
+//#endregion
+export { nixExpr as A, sync as C, renderList as D, resolveFlakeSpec as E, DoctorFailed as M, renderNixValue as O, check as S, renderFlake as T, generateOptionTypeFile as _, renderGeneratedOptions as a, doctor as b, optionMetadataDocumentToJson as c, defaultHomeManagerOptionPaths as d, defaultNixOSOptionPaths as f, collectUnsupportedOptions as g, renderOptionProbeExpression as h, readOptionMetadataDocument as i, rawNix as j, nixAttrPath as k, parseOptionMetadataDocument as l, projectFlakeInput as m, generateProjectOptionTypes as n, resolveFlakeReference as o, flakeInput as p, probeProjectOptions as r, makeOptionMetadataDocument as s, defaultOptionScopes as t, parseOptionProbePayload as u, generateOptionTypes as v, Flake as w, renderDoctorReport as x, toTypeScriptType as y };
+
+//# sourceMappingURL=options-CE3YO7EL.mjs.map