typeflake 0.0.1-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hauke Schnau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,167 @@
+# Typeflake
+
+Typeflake is an experiment in writing Nix flakes, NixOS systems, Home Manager
+profiles, and dev shells with TypeScript and Effect while keeping Nix as the
+execution truth.
+
+The source of intent is `flake.ts`. Typeflake evaluates that TypeScript program,
+validates it, and emits ordinary, inspectable Nix artifacts such as `flake.nix`
+and generated modules. Nix still evaluates, builds, and checks the result.
+
+## Product Thesis
+
+Nix the ecosystem is excellent. Nix the language and tooling can be hard to
+write at scale. Typeflake keeps the ecosystem and execution model, but adds:
+
+- TypeScript-native authoring ergonomics.
+- project-local types generated from the pinned flake/module universe.
+- explicit typed escape hatches for raw Nix.
+- Effect-powered validation, diagnostics, and command orchestration.
+- taint tracking for generation-time effects such as environment, filesystem,
+  process, network, time, and host state.
+
+## Initial Scope
+
+The first milestone focuses on:
+
+- `flake.ts` as the primary entrypoint.
+- generated `flake.nix`.
+- NixOS configurations.
+- Home Manager configurations.
+- dev shells.
+- option extraction from the real pinned Nix module graph.
+- a tiny CLI with `sync` and `check`.
+
+## Current Shape
+
+TypeScript remains the composition system. Typeflake provides typed boundaries
+for Nix concepts and generates ordinary Nix artifacts:
+
+```ts
+import { Flake, Home, NixOS, pkgs } from "typeflake";
+
+const systemConfig = NixOS.config({
+  services: {
+    openssh: {
+      enable: true,
+    },
+  },
+  environment: {
+    systemPackages: [pkgs.git, pkgs.neovim],
+  },
+  system: {
+    stateVersion: "25.11",
+  },
+});
+
+const homeConfig = {
+  home: {
+    stateVersion: "25.11",
+  },
+  programs: {
+    git: {
+      enable: true,
+    },
+  },
+} satisfies Home.Config;
+
+export default Flake.make({
+  inputs: Flake.inputs({
+    nixpkgs: Flake.input("nixpkgs", "github:NixOS/nixpkgs/nixos-unstable"),
+    homeManager: Flake.input("homeManager", "github:nix-community/home-manager"),
+  }),
+  outputs: ({ homeManager }) => ({
+    nixosConfigurations: {
+      framework: NixOS.configuration({
+        system: "x86_64-linux",
+        modules: [
+          NixOS.module(systemConfig),
+          Home.nixosModule(homeManager, {
+            users: {
+              hauke: homeConfig,
+            },
+          }),
+        ],
+      }),
+    },
+  }),
+});
+```
+
+The option bridge now has a narrow working vertical slice:
+
+- a Nix-side probe that evaluates pinned NixOS and Home Manager option metadata,
+- project-local `typeflake options probe` and `typeflake options generate`
+  commands,
+- generated fixture types for a small but broader option subset,
+- Attest-backed type assertions for the generated config surface,
+- and a golden test that compares real `nix eval --json` output to the committed
+  option fixture.
+
+Deployment and broader orchestration are intentionally later milestones. The
+first bet to prove is the type model.
+
+## Install
+
+This is a very early alpha. The package is published for experimentation and
+name reservation, not for production use yet.
+
+```sh
+npm install --save-dev typeflake@next
+```
+
+Typeflake currently expects Node.js 22 or newer. It also ships with
+TypeScript-Go Native Preview and the Effect TSGO plugin so the CLI can run its
+own authoring checks after installation.
+
+For consumer projects on this alpha, use ESM/NodeNext TypeScript settings. While
+Effect v4 and TypeScript-Go are both still moving, `skipLibCheck` may be needed
+in downstream projects that import Typeflake's declarations.
+
+## Generated Type Lifecycle
+
+Generated option types belong to the consuming project. Typeflake reads that
+project's locked flake inputs, asks Nix to evaluate the real option graph, and
+then emits TypeScript declarations from the resulting metadata.
+
+```sh
+typeflake options probe \
+  --flake . \
+  --system x86_64-linux \
+  --scope nixos \
+  --scope home-manager \
+  --output .typeflake/options.json
+
+typeflake options generate \
+  --input .typeflake/options.json \
+  --output .typeflake/options.ts
+```
+
+Use `--nixpkgs-input` and `--home-manager-input` when a project uses different
+flake input names. After changing `flake.lock`, rerun both commands and then run
+the normal checks.
+
+The trust boundary is intentionally simple:
+
+- `flake.lock` pins the Nix universe.
+- Nix evaluates the real NixOS/Home Manager module options.
+- Typeflake parses that metadata into a typed IR.
+- TypeScript checks authoring against generated declarations.
+- Nix remains the execution truth for evaluation, checks, and builds.
+
+Unsupported option shapes are never erased into `any`. The generator keeps them
+explicit with `UnsupportedNixOption<...>` escape hatches, and
+`typeflake options generate --strict` fails if any remain.
+
+## Documents
+
+- [Vision](docs/VISION.md)
+- [Architecture](docs/ARCHITECTURE.md)
+- [First Spike](docs/SPIKE.md)
+- [Prior Art](docs/PRIOR_ART.md)
+
+## Status
+
+Implementation spike in progress. The repository can render and check a small
+flake, run Effect-native CLI commands, and validate a first generated option
+type subset.

package/bin/typeflake.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../dist/cli.mjs";

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { C as sync, M as DoctorFailed, S as check, b as doctor, n as generateProjectOptionTypes, r as probeProjectOptions, t as defaultOptionScopes, x as renderDoctorReport } from "./options-CE3YO7EL.mjs";
+import * as Effect from "effect/Effect";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import * as Console from "effect/Console";
+import { Command, Flag } from "effect/unstable/cli";
+//#endregion
+//#region src/cli.ts
+const { version } = {
+	name: "typeflake",
+	version: "0.0.1-alpha.0",
+	description: "TypeScript and Effect authoring for real Nix flakes.",
+	keywords: [
+		"effect",
+		"flakes",
+		"nix",
+		"nixos",
+		"typescript"
+	],
+	homepage: "https://git.schnau.dev/schnau/typeflake",
+	bugs: { "url": "https://git.schnau.dev/schnau/typeflake/issues" },
+	license: "MIT",
+	author: "Hauke Schnau <hauke@schnau.dev>",
+	repository: {
+		"type": "git",
+		"url": "git+ssh://git@git.schnau.dev/schnau/typeflake.git"
+	},
+	bin: { "typeflake": "bin/typeflake.js" },
+	files: [
+		"bin",
+		"dist",
+		"LICENSE",
+		"README.md"
+	],
+	type: "module",
+	types: "./dist/index.d.mts",
+	exports: { ".": {
+		"types": "./dist/index.d.mts",
+		"import": "./dist/index.mjs"
+	} },
+	publishConfig: { "access": "public" },
+	scripts: {
+		"build": "tsdown src/index.ts src/cli.ts --format esm --dts --out-dir dist --clean --target node22 --platform node",
+		"check": "nub run check:types && nub run check:effect && nub run lint && nub run test && nub run format:check",
+		"check:effect": "tsgo --noEmit --project tsconfig.json",
+		"check:types": "oxlint . --type-aware --type-check --deny-warnings",
+		"format": "oxfmt .",
+		"format:check": "oxfmt . --check",
+		"lint": "oxlint . --type-aware --deny-warnings --report-unused-disable-directives",
+		"pack:dry": "npm pack --dry-run",
+		"prepack": "nub run build",
+		"prepublishOnly": "nub run check",
+		"test": "vitest run",
+		"tsgo:patch": "effect-tsgo patch",
+		"typeflake": "nub src/cli.ts"
+	},
+	dependencies: {
+		"@effect/platform-node": "4.0.0-beta.93",
+		"@effect/tsgo": "0.16.0",
+		"@typescript/native-preview": "7.0.0-dev.20260703.1",
+		"effect": "4.0.0-beta.93"
+	},
+	devDependencies: {
+		"@arktype/attest": "0.56.2",
+		"@effect/vitest": "4.0.0-beta.93",
+		"@types/node": "24.10.0",
+		"@vitest/runner": "4.1.4",
+		"oxfmt": "0.57.0",
+		"oxlint": "1.72.0",
+		"oxlint-tsgolint": "0.24.0",
+		"tsdown": "0.22.3",
+		"typescript": "5.9.3",
+		"vitest": "4.1.4"
+	},
+	engines: { "node": ">=22" },
+	packageManager: "pnpm@11.9.0"
+};
+const flakeFileFlags = {
+	input: Flag.string("input").pipe(Flag.withAlias("i"), Flag.withDescription("TypeScript flake entrypoint"), Flag.withDefault("flake.ts")),
+	output: Flag.string("output").pipe(Flag.withAlias("o"), Flag.withDescription("Generated Nix flake path"), Flag.withDefault("flake.nix"))
+};
+const syncCommand = Command.make("sync", flakeFileFlags, (options) => sync(options).pipe(Effect.flatMap(() => Console.log(`Generated ${options.output}`)))).pipe(Command.withDescription("Generate a Nix flake from flake.ts"));
+const checkCommand = Command.make("check", flakeFileFlags, (options) => check(options)).pipe(Command.withDescription("Generate a Nix flake and run nix flake check"));
+const optionScopeFlag = Flag.choice("scope", ["nixos", "home-manager"]).pipe(Flag.atLeast(0), Flag.withDescription("Option scope to probe; repeat for multiple scopes"));
+const optionsProbeCommand = Command.make("probe", {
+	flake: Flag.string("flake").pipe(Flag.withDescription("Project flake root used for locked option metadata"), Flag.withDefault(".")),
+	homeManagerInput: Flag.string("home-manager-input").pipe(Flag.withDescription("Home Manager input name in the project flake"), Flag.withDefault("home-manager")),
+	nixpkgsInput: Flag.string("nixpkgs-input").pipe(Flag.withDescription("nixpkgs input name in the project flake"), Flag.withDefault("nixpkgs")),
+	output: Flag.string("output").pipe(Flag.withAlias("o"), Flag.withDescription("Stable option metadata JSON output path"), Flag.withDefault(".typeflake/options.json")),
+	scope: optionScopeFlag,
+	system: Flag.string("system").pipe(Flag.withDescription("Nix system used while evaluating option metadata"), Flag.withDefault("x86_64-linux"))
+}, (options) => probeProjectOptions({
+	flake: options.flake,
+	homeManagerInput: options.homeManagerInput,
+	nixpkgsInput: options.nixpkgsInput,
+	output: options.output,
+	scopes: normalizeCliScopes(options.scope),
+	system: options.system
+}).pipe(Effect.flatMap((document) => Console.log(`Wrote ${document.options.length} option records to ${options.output}`)))).pipe(Command.withDescription("Probe project-local pinned Nix option metadata"));
+const optionsGenerateCommand = Command.make("generate", {
+	input: Flag.string("input").pipe(Flag.withAlias("i"), Flag.withDescription("Stable option metadata JSON input path"), Flag.withDefault(".typeflake/options.json")),
+	output: Flag.string("output").pipe(Flag.withAlias("o"), Flag.withDescription("Generated TypeScript option type output path"), Flag.withDefault(".typeflake/options.ts")),
+	strict: Flag.boolean("strict").pipe(Flag.withDescription("Fail when generated types contain unsupported option shapes"))
+}, (options) => generateProjectOptionTypes(options).pipe(Effect.flatMap(({ document, unsupported }) => Console.log(`Wrote ${document.options.length} option types to ${options.output}` + renderUnsupportedSummary(unsupported.length))))).pipe(Command.withDescription("Generate TypeScript option types from probed metadata"));
+const optionsCommand = Command.make("options").pipe(Command.withDescription("Probe and generate project-local option types"), Command.withSubcommands([optionsProbeCommand, optionsGenerateCommand]));
+const doctorCommand = Command.make("doctor", { project: Flag.string("project").pipe(Flag.withDescription("TypeScript project checked before loading flake.ts"), Flag.withDefault("tsconfig.json")) }, (options) => Effect.gen(function* () {
+	const report = yield* doctor(options);
+	yield* Console.log(renderDoctorReport(report));
+	if (!report.ok) return yield* new DoctorFailed({ failedChecks: report.checks.filter((doctorCheck) => !doctorCheck.ok).map((doctorCheck) => doctorCheck.name) });
+})).pipe(Command.withDescription("Check local Typeflake tooling and compiler health"));
+const command = Command.make("typeflake").pipe(Command.withDescription("TypeScript and Effect authoring for real Nix flakes"), Command.withSubcommands([
+	syncCommand,
+	checkCommand,
+	doctorCommand,
+	optionsCommand
+]));
+const normalizeCliScopes = (scopes) => scopes.length === 0 ? defaultOptionScopes : scopes;
+const renderUnsupportedSummary = (count) => count === 0 ? "" : ` (${count} unsupported option shapes kept explicit)`;
+Command.run(command, { version }).pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain);
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map

package/dist/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":["packageJson"],"sources":["../package.json","../src/cli.ts"],"sourcesContent":["","#!/usr/bin/env node\n\nimport { NodeRuntime, NodeServices } from \"@effect/platform-node\";\nimport * as Console from \"effect/Console\";\nimport * as Effect from \"effect/Effect\";\nimport { Command, Flag } from \"effect/unstable/cli\";\nimport { check } from \"./check.ts\";\nimport { doctor, renderDoctorReport } from \"./doctor.ts\";\nimport { DoctorFailed } from \"./errors.ts\";\nimport {\n  defaultOptionScopes,\n  generateProjectOptionTypes,\n  probeProjectOptions,\n  type OptionScope,\n} from \"./options.ts\";\nimport { sync } from \"./sync.ts\";\nimport packageJson from \"../package.json\" with { type: \"json\" };\n\nconst { version } = packageJson;\n\nconst flakeFileFlags = {\n  input: Flag.string(\"input\").pipe(\n    Flag.withAlias(\"i\"),\n    Flag.withDescription(\"TypeScript flake entrypoint\"),\n    Flag.withDefault(\"flake.ts\"),\n  ),\n  output: Flag.string(\"output\").pipe(\n    Flag.withAlias(\"o\"),\n    Flag.withDescription(\"Generated Nix flake path\"),\n    Flag.withDefault(\"flake.nix\"),\n  ),\n};\n\nconst syncCommand = Command.make(\"sync\", flakeFileFlags, (options) =>\n  sync(options).pipe(Effect.flatMap(() => Console.log(`Generated ${options.output}`))),\n).pipe(Command.withDescription(\"Generate a Nix flake from flake.ts\"));\n\nconst checkCommand = Command.make(\"check\", flakeFileFlags, (options) => check(options)).pipe(\n  Command.withDescription(\"Generate a Nix flake and run nix flake check\"),\n);\n\nconst optionScopeFlag = Flag.choice(\"scope\", [\"nixos\", \"home-manager\"]).pipe(\n  Flag.atLeast(0),\n  Flag.withDescription(\"Option scope to probe; repeat for multiple scopes\"),\n);\n\nconst optionsProbeCommand = Command.make(\n  \"probe\",\n  {\n    flake: Flag.string(\"flake\").pipe(\n      Flag.withDescription(\"Project flake root used for locked option metadata\"),\n      Flag.withDefault(\".\"),\n    ),\n    homeManagerInput: Flag.string(\"home-manager-input\").pipe(\n      Flag.withDescription(\"Home Manager input name in the project flake\"),\n      Flag.withDefault(\"home-manager\"),\n    ),\n    nixpkgsInput: Flag.string(\"nixpkgs-input\").pipe(\n      Flag.withDescription(\"nixpkgs input name in the project flake\"),\n      Flag.withDefault(\"nixpkgs\"),\n    ),\n    output: Flag.string(\"output\").pipe(\n      Flag.withAlias(\"o\"),\n      Flag.withDescription(\"Stable option metadata JSON output path\"),\n      Flag.withDefault(\".typeflake/options.json\"),\n    ),\n    scope: optionScopeFlag,\n    system: Flag.string(\"system\").pipe(\n      Flag.withDescription(\"Nix system used while evaluating option metadata\"),\n      Flag.withDefault(\"x86_64-linux\"),\n    ),\n  },\n  (options) =>\n    probeProjectOptions({\n      flake: options.flake,\n      homeManagerInput: options.homeManagerInput,\n      nixpkgsInput: options.nixpkgsInput,\n      output: options.output,\n      scopes: normalizeCliScopes(options.scope),\n      system: options.system,\n    }).pipe(\n      Effect.flatMap((document) =>\n        Console.log(`Wrote ${document.options.length} option records to ${options.output}`),\n      ),\n    ),\n).pipe(Command.withDescription(\"Probe project-local pinned Nix option metadata\"));\n\nconst optionsGenerateCommand = Command.make(\n  \"generate\",\n  {\n    input: Flag.string(\"input\").pipe(\n      Flag.withAlias(\"i\"),\n      Flag.withDescription(\"Stable option metadata JSON input path\"),\n      Flag.withDefault(\".typeflake/options.json\"),\n    ),\n    output: Flag.string(\"output\").pipe(\n      Flag.withAlias(\"o\"),\n      Flag.withDescription(\"Generated TypeScript option type output path\"),\n      Flag.withDefault(\".typeflake/options.ts\"),\n    ),\n    strict: Flag.boolean(\"strict\").pipe(\n      Flag.withDescription(\"Fail when generated types contain unsupported option shapes\"),\n    ),\n  },\n  (options) =>\n    generateProjectOptionTypes(options).pipe(\n      Effect.flatMap(({ document, unsupported }) =>\n        Console.log(\n          `Wrote ${document.options.length} option types to ${options.output}` +\n            renderUnsupportedSummary(unsupported.length),\n        ),\n      ),\n    ),\n).pipe(Command.withDescription(\"Generate TypeScript option types from probed metadata\"));\n\nconst optionsCommand = Command.make(\"options\").pipe(\n  Command.withDescription(\"Probe and generate project-local option types\"),\n  Command.withSubcommands([optionsProbeCommand, optionsGenerateCommand]),\n);\n\nconst doctorCommand = Command.make(\n  \"doctor\",\n  {\n    project: Flag.string(\"project\").pipe(\n      Flag.withDescription(\"TypeScript project checked before loading flake.ts\"),\n      Flag.withDefault(\"tsconfig.json\"),\n    ),\n  },\n  (options) =>\n    Effect.gen(function* () {\n      const report = yield* doctor(options);\n      yield* Console.log(renderDoctorReport(report));\n\n      if (!report.ok) {\n        return yield* new DoctorFailed({\n          failedChecks: report.checks\n            .filter((doctorCheck) => !doctorCheck.ok)\n            .map((doctorCheck) => doctorCheck.name),\n        });\n      }\n\n      return undefined;\n    }),\n).pipe(Command.withDescription(\"Check local Typeflake tooling and compiler health\"));\n\nconst command = Command.make(\"typeflake\").pipe(\n  Command.withDescription(\"TypeScript and Effect authoring for real Nix flakes\"),\n  Command.withSubcommands([syncCommand, checkCommand, doctorCommand, optionsCommand]),\n);\n\nconst normalizeCliScopes = (scopes: readonly OptionScope[]): readonly OptionScope[] =>\n  scopes.length === 0 ? defaultOptionScopes : scopes;\n\nconst renderUnsupportedSummary = (count: number): string =>\n  count === 0 ? \"\" : ` (${count} unsupported option shapes kept explicit)`;\n\nCommand.run(command, { version }).pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain);\n"],"mappings":";;;;;;;;ACkBA,MAAM,EAAE,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAA;AAEpB,MAAM,iBAAiB;CACrB,OAAO,KAAK,OAAO,OAAO,CAAC,CAAC,KAC1B,KAAK,UAAU,GAAG,GAClB,KAAK,gBAAgB,6BAA6B,GAClD,KAAK,YAAY,UAAU,CAC7B;CACA,QAAQ,KAAK,OAAO,QAAQ,CAAC,CAAC,KAC5B,KAAK,UAAU,GAAG,GAClB,KAAK,gBAAgB,0BAA0B,GAC/C,KAAK,YAAY,WAAW,CAC9B;AACF;AAEA,MAAM,cAAc,QAAQ,KAAK,QAAQ,iBAAiB,YACxD,KAAK,OAAO,CAAC,CAAC,KAAK,OAAO,cAAc,QAAQ,IAAI,aAAa,QAAQ,QAAQ,CAAC,CAAC,CACrF,CAAC,CAAC,KAAK,QAAQ,gBAAgB,oCAAoC,CAAC;AAEpE,MAAM,eAAe,QAAQ,KAAK,SAAS,iBAAiB,YAAY,MAAM,OAAO,CAAC,CAAC,CAAC,KACtF,QAAQ,gBAAgB,8CAA8C,CACxE;AAEA,MAAM,kBAAkB,KAAK,OAAO,SAAS,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,KACtE,KAAK,QAAQ,CAAC,GACd,KAAK,gBAAgB,mDAAmD,CAC1E;AAEA,MAAM,sBAAsB,QAAQ,KAClC,SACA;CACE,OAAO,KAAK,OAAO,OAAO,CAAC,CAAC,KAC1B,KAAK,gBAAgB,oDAAoD,GACzE,KAAK,YAAY,GAAG,CACtB;CACA,kBAAkB,KAAK,OAAO,oBAAoB,CAAC,CAAC,KAClD,KAAK,gBAAgB,8CAA8C,GACnE,KAAK,YAAY,cAAc,CACjC;CACA,cAAc,KAAK,OAAO,eAAe,CAAC,CAAC,KACzC,KAAK,gBAAgB,yCAAyC,GAC9D,KAAK,YAAY,SAAS,CAC5B;CACA,QAAQ,KAAK,OAAO,QAAQ,CAAC,CAAC,KAC5B,KAAK,UAAU,GAAG,GAClB,KAAK,gBAAgB,yCAAyC,GAC9D,KAAK,YAAY,yBAAyB,CAC5C;CACA,OAAO;CACP,QAAQ,KAAK,OAAO,QAAQ,CAAC,CAAC,KAC5B,KAAK,gBAAgB,kDAAkD,GACvE,KAAK,YAAY,cAAc,CACjC;AACF,IACC,YACC,oBAAoB;CAClB,OAAO,QAAQ;CACf,kBAAkB,QAAQ;CAC1B,cAAc,QAAQ;CACtB,QAAQ,QAAQ;CAChB,QAAQ,mBAAmB,QAAQ,KAAK;CACxC,QAAQ,QAAQ;AAClB,CAAC,CAAC,CAAC,KACD,OAAO,SAAS,aACd,QAAQ,IAAI,SAAS,SAAS,QAAQ,OAAO,qBAAqB,QAAQ,QAAQ,CACpF,CACF,CACJ,CAAC,CAAC,KAAK,QAAQ,gBAAgB,gDAAgD,CAAC;AAEhF,MAAM,yBAAyB,QAAQ,KACrC,YACA;CACE,OAAO,KAAK,OAAO,OAAO,CAAC,CAAC,KAC1B,KAAK,UAAU,GAAG,GAClB,KAAK,gBAAgB,wCAAwC,GAC7D,KAAK,YAAY,yBAAyB,CAC5C;CACA,QAAQ,KAAK,OAAO,QAAQ,CAAC,CAAC,KAC5B,KAAK,UAAU,GAAG,GAClB,KAAK,gBAAgB,8CAA8C,GACnE,KAAK,YAAY,uBAAuB,CAC1C;CACA,QAAQ,KAAK,QAAQ,QAAQ,CAAC,CAAC,KAC7B,KAAK,gBAAgB,6DAA6D,CACpF;AACF,IACC,YACC,2BAA2B,OAAO,CAAC,CAAC,KAClC,OAAO,SAAS,EAAE,UAAU,kBAC1B,QAAQ,IACN,SAAS,SAAS,QAAQ,OAAO,mBAAmB,QAAQ,WAC1D,yBAAyB,YAAY,MAAM,CAC/C,CACF,CACF,CACJ,CAAC,CAAC,KAAK,QAAQ,gBAAgB,uDAAuD,CAAC;AAEvF,MAAM,iBAAiB,QAAQ,KAAK,SAAS,CAAC,CAAC,KAC7C,QAAQ,gBAAgB,+CAA+C,GACvE,QAAQ,gBAAgB,CAAC,qBAAqB,sBAAsB,CAAC,CACvE;AAEA,MAAM,gBAAgB,QAAQ,KAC5B,UACA,EACE,SAAS,KAAK,OAAO,SAAS,CAAC,CAAC,KAC9B,KAAK,gBAAgB,oDAAoD,GACzE,KAAK,YAAY,eAAe,CAClC,EACF,IACC,YACC,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,OAAO,OAAO;CACpC,OAAO,QAAQ,IAAI,mBAAmB,MAAM,CAAC;CAE7C,IAAI,CAAC,OAAO,IACV,OAAO,OAAO,IAAI,aAAa,EAC7B,cAAc,OAAO,OAClB,QAAQ,gBAAgB,CAAC,YAAY,EAAE,CAAC,CACxC,KAAK,gBAAgB,YAAY,IAAI,EAC1C,CAAC;AAIL,CAAC,CACL,CAAC,CAAC,KAAK,QAAQ,gBAAgB,mDAAmD,CAAC;AAEnF,MAAM,UAAU,QAAQ,KAAK,WAAW,CAAC,CAAC,KACxC,QAAQ,gBAAgB,qDAAqD,GAC7E,QAAQ,gBAAgB;CAAC;CAAa;CAAc;CAAe;AAAc,CAAC,CACpF;AAEA,MAAM,sBAAsB,WAC1B,OAAO,WAAW,IAAI,sBAAsB;AAE9C,MAAM,4BAA4B,UAChC,UAAU,IAAI,KAAK,KAAK,MAAM;AAEhC,QAAQ,IAAI,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,aAAa,KAAK,GAAG,YAAY,OAAO"}