alchemy-docker-k3s 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2026 toolbar23
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

package/README.md

@@ -0,0 +1,8 @@
+# alchemy-docker-k3s
+
+Persistent single-node local K3s clusters, backed by k3d, that implement
+Alchemy's `Kubernetes.ClusterLike` contract.
+
+See the
+[repository documentation](https://github.com/toolbar23/alchemy-k3s#local-cluster)
+for configuration, port mapping, and update behavior.

package/dist/index.d.mts

@@ -0,0 +1,104 @@
+import * as Docker from "alchemy/Docker";
+import * as Effect from "effect/Effect";
+import { Resource } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import * as Redacted from "effect/Redacted";
+import * as Layer from "effect/Layer";
+import * as Kubernetes from "alchemy/Kubernetes";
+//#region src/providers.d.ts
+declare const Providers_base: Provider.ProviderCollection<Providers, "DockerK3s">;
+declare class Providers extends Providers_base {}
+declare const providers: () => Layer.Layer<Providers, never, never>;
+//#endregion
+//#region ../shared/src/types.d.ts
+type DayOfWeek = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday";
+interface UpdateWindow {
+  /** Days on which an update may start. */
+  days: DayOfWeek[];
+  /** Inclusive start in 24-hour HH:mm form. */
+  startTime: `${number}:${number}`;
+  /** Exclusive end in 24-hour HH:mm form. */
+  endTime: `${number}:${number}`;
+  /** IANA time-zone name, for example Europe/Berlin. */
+  timeZone: string;
+}
+interface K3sDefinition {
+  /** A pinned Kubernetes minor channel such as v1.35. */
+  channel: `v1.${number}`;
+  /** Required maintenance window for automatic patch updates. */
+  updateWindow: UpdateWindow;
+  clusterCidr?: string;
+  serviceCidr?: string;
+  clusterDns?: string;
+  addons?: {
+    traefik?: boolean;
+    metricsServer?: boolean;
+  };
+  /** K3s' built-in Flannel data plane. @default "vxlan" */
+  flannelBackend?: "vxlan" | "wireguard-native";
+}
+interface NormalizedK3sDefinition {
+  channel: `v1.${number}`;
+  updateWindow: UpdateWindow;
+  clusterCidr: string;
+  serviceCidr: string;
+  clusterDns: string;
+  addons: {
+    traefik: boolean;
+    metricsServer: boolean;
+  };
+  flannelBackend: "vxlan" | "wireguard-native";
+}
+interface ClusterVersion {
+  node: string;
+  version: string;
+}
+//#endregion
+//#region src/types.d.ts
+interface PortMapping {
+  hostPort: number;
+  containerPort: number;
+  protocol?: "tcp" | "udp";
+}
+interface ClusterProps {
+  k3s: K3sDefinition;
+  context?: Docker.Docker.ContextRef;
+  /** Fixed host port for the Kubernetes API. Omit for a random free port. */
+  apiPort?: number;
+  /** Host mappings through k3d's server load balancer. */
+  ports?: PortMapping[];
+}
+interface ClusterStateProps {
+  name: string;
+  k3s: NormalizedK3sDefinition;
+  context?: Docker.Docker.ContextRef;
+  apiPort?: number;
+  ports: PortMapping[];
+  volume: {
+    name: string;
+  };
+  configFingerprint: string;
+}
+interface ClusterAttributes {
+  connection: Kubernetes.Connection;
+  endpoint: string;
+  kubeconfigPath: string;
+  currentVersions: ClusterVersion[];
+  currentVersion: string;
+  channel: `v1.${number}`;
+  name: string;
+  volumeName: string;
+  /** K3s bootstrap token retained so a replacement container can decrypt its datastore. */
+  token: Redacted.Redacted<string>;
+  configFingerprint: string;
+}
+type ClusterResource = Resource<"Docker.K3s.Cluster", ClusterStateProps, ClusterAttributes, never, Providers>;
+type Cluster$1 = ClusterResource;
+//#endregion
+//#region src/cluster.d.ts
+declare const Cluster: (id: string, props: ClusterProps) => Effect.Effect<ClusterResource, never, Providers | Docker.Providers>;
+//#endregion
+//#region src/cluster-state.d.ts
+declare const ClusterState: import("alchemy").ResourceClass<ClusterResource>;
+//#endregion
+export { Cluster, type ClusterAttributes, type Cluster$1 as ClusterInstance, type ClusterProps, ClusterState, type K3sDefinition, type PortMapping, Providers, providers };

package/dist/index.mjs

@@ -0,0 +1,415 @@
+import * as Docker from "alchemy/Docker";
+import * as Effect from "effect/Effect";
+import { Resource, isResolved } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import * as Redacted from "effect/Redacted";
+import { parse } from "yaml";
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import * as Layer from "effect/Layer";
+//#region ../shared/src/definition.ts
+const DAYS = [
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday",
+	"Sunday"
+];
+const HH_MM = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
+const CHANNEL = /^v1\.(\d+)$/;
+const ipv4Number = (address) => {
+	const parts = address.split(".").map(Number);
+	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return;
+	return parts.reduce((value, part) => (value << 8 | part) >>> 0, 0);
+};
+const ipv4CidrRange = (cidr) => {
+	const [address, prefixText, extra] = cidr.split("/");
+	const value = address === void 0 ? void 0 : ipv4Number(address);
+	const prefix = Number(prefixText);
+	if (extra !== void 0 || value === void 0 || !Number.isInteger(prefix) || prefix < 0 || prefix > 32) return;
+	const mask = prefix === 0 ? 0 : 4294967295 << 32 - prefix >>> 0;
+	const start = (value & mask) >>> 0;
+	if (value !== start) return void 0;
+	return [start, (start | ~mask) >>> 0];
+};
+const validateChannel = (channel) => {
+	if (!CHANNEL.test(channel)) throw new Error(`K3s channel must pin one minor as v1.<minor>; received ${JSON.stringify(channel)}`);
+	return channel;
+};
+const validateUpdateWindow = (window) => {
+	if (window.days.length === 0 || window.days.some((day) => !DAYS.includes(day))) throw new Error("updateWindow.days must contain valid weekday names");
+	if (!HH_MM.test(window.startTime) || !HH_MM.test(window.endTime)) throw new Error("updateWindow times must use 24-hour HH:mm form");
+	if (window.startTime === window.endTime) throw new Error("updateWindow startTime and endTime must differ");
+	try {
+		new Intl.DateTimeFormat("en", { timeZone: window.timeZone }).format();
+	} catch {
+		throw new Error(`updateWindow.timeZone must be an IANA time zone; received ${JSON.stringify(window.timeZone)}`);
+	}
+	return window;
+};
+const normalizeK3sDefinition = (definition) => {
+	const normalized = {
+		channel: validateChannel(definition.channel),
+		updateWindow: validateUpdateWindow(definition.updateWindow),
+		clusterCidr: definition.clusterCidr ?? "10.244.0.0/16",
+		serviceCidr: definition.serviceCidr ?? "10.43.0.0/16",
+		clusterDns: definition.clusterDns ?? "10.43.0.10",
+		addons: {
+			traefik: definition.addons?.traefik ?? true,
+			metricsServer: definition.addons?.metricsServer ?? true
+		},
+		flannelBackend: definition.flannelBackend ?? "vxlan"
+	};
+	if (normalized.flannelBackend !== "vxlan" && normalized.flannelBackend !== "wireguard-native") throw new Error(`flannelBackend must be "vxlan" or "wireguard-native"; received ${JSON.stringify(normalized.flannelBackend)}`);
+	const ranges = [["clusterCidr", normalized.clusterCidr], ["serviceCidr", normalized.serviceCidr]];
+	for (const [name, cidr] of ranges) if (ipv4CidrRange(cidr) === void 0) throw new Error(`${name} must be an IPv4 CIDR; received ${JSON.stringify(cidr)}`);
+	const clusterRange = ipv4CidrRange(normalized.clusterCidr);
+	const serviceRange = ipv4CidrRange(normalized.serviceCidr);
+	if (clusterRange[0] <= serviceRange[1] && serviceRange[0] <= clusterRange[1]) throw new Error("clusterCidr and serviceCidr must not overlap");
+	const dns = ipv4Number(normalized.clusterDns);
+	if (dns === void 0 || dns < serviceRange[0] || dns > serviceRange[1]) throw new Error("clusterDns must be an IPv4 address inside serviceCidr");
+	return normalized;
+};
+const partsFor = (date, timeZone) => Object.fromEntries(new Intl.DateTimeFormat("en-US", {
+	timeZone,
+	weekday: "long",
+	hour: "2-digit",
+	minute: "2-digit",
+	hourCycle: "h23"
+}).formatToParts(date).map(({ type, value }) => [type, value]));
+const isInsideUpdateWindow = (window, date = /* @__PURE__ */ new Date()) => {
+	validateUpdateWindow(window);
+	const parts = partsFor(date, window.timeZone);
+	const weekday = parts.weekday;
+	const current = `${parts.hour}:${parts.minute}`;
+	if (window.startTime < window.endTime) return window.days.includes(weekday) && current >= window.startTime && current < window.endTime;
+	if (current >= window.startTime) return window.days.includes(weekday);
+	if (current >= window.endTime) return false;
+	const previousParts = partsFor(/* @__PURE__ */ new Date(date.getTime() - 432e5), window.timeZone);
+	return window.days.includes(previousParts.weekday);
+};
+const assertSameMinor = (current, desired) => {
+	const currentMinor = /^v?(\d+\.\d+)\./.exec(current)?.[1];
+	const desiredMinor = /^v?(\d+\.\d+)\./.exec(desired)?.[1];
+	if (currentMinor !== void 0 && desiredMinor !== void 0 && currentMinor !== desiredMinor) throw new Error(`Automatic updates cannot change Kubernetes minor (${current} -> ${desired}); change k3s.channel explicitly`);
+};
+//#endregion
+//#region ../shared/src/channel.ts
+const resolveChannelVersion = async (channel, fetcher = fetch) => {
+	validateChannel(channel);
+	const response = await fetcher(`https://update.k3s.io/v1-release/channels/${channel}`, {
+		redirect: "follow",
+		signal: AbortSignal.timeout(15e3)
+	});
+	if (!response.ok) throw new Error(`Unable to resolve K3s channel ${channel}: HTTP ${response.status}`);
+	const resolvedUrl = decodeURIComponent(response.url);
+	const match = /(?:^|\/)(v\d+\.\d+\.\d+(?:\+k3s\d+)?)(?:$|[/?#])/.exec(resolvedUrl);
+	if (match?.[1] !== void 0) return match[1];
+	const body = (await response.text()).trim();
+	const bodyMatch = /v\d+\.\d+\.\d+(?:\+k3s\d+)?/.exec(body);
+	if (bodyMatch?.[0] !== void 0) return bodyMatch[0];
+	throw new Error(`K3s channel ${channel} returned no recognizable release version`);
+};
+//#endregion
+//#region ../shared/src/kubeconfig.ts
+const kubeconfigPath = (provider, fqn) => {
+	const safe = fqn.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-|-$/g, "");
+	return resolve(join(".alchemy", "kubeconfigs", provider, `${safe}.yaml`));
+};
+const writeKubeconfig = async (path, contents) => {
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(path, contents, {
+		encoding: "utf8",
+		mode: 384
+	});
+	await chmod(path, 384);
+};
+//#endregion
+//#region ../shared/src/process.ts
+const execute = promisify(execFile);
+const run = async (file, args, options = {}) => {
+	if (options.input !== void 0) return await new Promise((resolve, reject) => {
+		execFile(file, args, {
+			encoding: "utf8",
+			timeout: options.timeout ?? 12e4,
+			maxBuffer: 16777216,
+			env: options.env
+		}, (error, stdout, stderr) => {
+			if (error !== null) {
+				reject(new Error(`${file} ${args.join(" ")} failed: ${stderr.trim() || error.message}`, { cause: error }));
+				return;
+			}
+			resolve({
+				stdout,
+				stderr
+			});
+		}).stdin?.end(options.input);
+	});
+	const result = await execute(file, args, {
+		encoding: "utf8",
+		timeout: options.timeout ?? 12e4,
+		maxBuffer: 16777216,
+		env: options.env
+	});
+	return {
+		stdout: result.stdout,
+		stderr: result.stderr
+	};
+};
+//#endregion
+//#region src/k3d.ts
+const contextName = (context) => {
+	if (context === void 0) return void 0;
+	return typeof context === "string" ? context : context.name;
+};
+const dockerEnvironment = async (context) => {
+	const name = contextName(context);
+	if (name === void 0 || name === "default") return process.env;
+	const host = (await run("docker", [
+		"context",
+		"inspect",
+		name,
+		"--format",
+		"{{.Endpoints.docker.Host}}"
+	])).stdout.trim();
+	if (host.length === 0) throw new Error(`Docker context ${name} has no endpoint`);
+	return {
+		...process.env,
+		DOCKER_HOST: host
+	};
+};
+const requireK3d = async () => {
+	let output;
+	try {
+		output = (await run("k3d", ["version"])).stdout;
+	} catch (error) {
+		throw new Error("k3d >=5.9.0 <6 is required; install it from https://k3d.io", { cause: error });
+	}
+	const match = /k3d version v?(\d+)\.(\d+)\.(\d+)/.exec(output);
+	if (match === null || Number(match[1]) !== 5 || Number(match[2]) < 9) throw new Error(`k3d >=5.9.0 <6 is required; received ${output.trim()}`);
+};
+const buildCreateArgs = (props, version, token) => {
+	const args = [
+		"cluster",
+		"create",
+		props.name,
+		"--servers",
+		"1",
+		"--agents",
+		"0",
+		"--image",
+		`rancher/k3s:${version.replace("+", "-")}`,
+		"--volume",
+		`${props.volume.name}:/var/lib/rancher/k3s@server:0`,
+		"--kubeconfig-update-default=false",
+		"--kubeconfig-switch-context=false",
+		"--wait"
+	];
+	if (props.apiPort !== void 0) args.push("--api-port", `127.0.0.1:${props.apiPort}`);
+	if (token !== void 0) args.push("--token", token);
+	for (const port of props.ports) args.push("--port", `${port.hostPort}:${port.containerPort}/${port.protocol ?? "tcp"}@loadbalancer`);
+	for (const value of [
+		`--cluster-cidr=${props.k3s.clusterCidr}`,
+		`--service-cidr=${props.k3s.serviceCidr}`,
+		`--cluster-dns=${props.k3s.clusterDns}`,
+		`--flannel-backend=${props.k3s.flannelBackend}`
+	]) args.push("--k3s-arg", `${value}@server:0`);
+	if (!props.k3s.addons.traefik) args.push("--k3s-arg", "--disable=traefik@server:0");
+	if (!props.k3s.addons.metricsServer) args.push("--k3s-arg", "--disable=metrics-server@server:0");
+	return args;
+};
+const inspectK3dCluster = async (props) => {
+	const env = await dockerEnvironment(props.context);
+	const listed = await run("k3d", [
+		"cluster",
+		"list",
+		"-o",
+		"json"
+	], { env });
+	if (!JSON.parse(listed.stdout).some((cluster) => cluster.name === props.name)) return void 0;
+	const detailed = await run("k3d", [
+		"cluster",
+		"list",
+		props.name,
+		"--token",
+		"-o",
+		"json"
+	], { env });
+	return JSON.parse(detailed.stdout)[0];
+};
+const parseK3sVersion = (output) => {
+	const match = /k3s version (v?\d+\.\d+\.\d+(?:[+-]k3s\d+)?)/.exec(output);
+	if (match?.[1] === void 0) throw new Error(`Cannot determine K3s version from ${output.trim()}`);
+	const version = match[1].replace("-k3s", "+k3s");
+	return version.startsWith("v") ? version : `v${version}`;
+};
+const runningVersion = async (props, cluster) => {
+	const server = cluster.nodes?.find((node) => node.role === "server");
+	if (server === void 0) throw new Error(`k3d cluster ${props.name} has no server node`);
+	const result = await run("docker", [
+		"exec",
+		server.name,
+		"k3s",
+		"--version"
+	], { env: await dockerEnvironment(props.context) });
+	return parseK3sVersion(result.stdout);
+};
+const createK3dCluster = async (props, version, token) => {
+	await run("k3d", buildCreateArgs(props, version, token), {
+		env: await dockerEnvironment(props.context),
+		timeout: 9e5
+	});
+};
+const deleteK3dCluster = async (props) => {
+	await run("k3d", [
+		"cluster",
+		"delete",
+		props.name
+	], {
+		env: await dockerEnvironment(props.context),
+		timeout: 6e5
+	});
+};
+const getKubeconfig = async (props) => (await run("k3d", [
+	"kubeconfig",
+	"get",
+	props.name
+], { env: await dockerEnvironment(props.context) })).stdout;
+//#endregion
+//#region src/cluster-state.ts
+const ClusterState = Resource("Docker.K3s.Cluster");
+const observe = async (fqn, props) => {
+	await requireK3d();
+	const cluster = await inspectK3dCluster(props);
+	if (cluster === void 0) return void 0;
+	const kubeconfig = await getKubeconfig(props);
+	const parsed = parse(kubeconfig);
+	const target = parsed.clusters?.[0]?.cluster?.server;
+	if (target === void 0) throw new Error("k3d returned a kubeconfig without an API endpoint");
+	const path = kubeconfigPath("docker", fqn);
+	await writeKubeconfig(path, kubeconfig);
+	const version = await runningVersion(props, cluster);
+	if (cluster.clusterToken === void 0 || cluster.clusterToken.length === 0) throw new Error("k3d returned no cluster token");
+	return {
+		connection: {
+			endpoint: target,
+			auth: {
+				kind: "kubeconfig",
+				path,
+				...parsed["current-context"] === void 0 ? {} : { context: parsed["current-context"] }
+			}
+		},
+		endpoint: target,
+		kubeconfigPath: path,
+		currentVersions: [{
+			node: `${props.name}-server-0`,
+			version
+		}],
+		currentVersion: version,
+		channel: props.k3s.channel,
+		name: props.name,
+		volumeName: props.volume.name,
+		token: Redacted.make(cluster.clusterToken),
+		configFingerprint: props.configFingerprint
+	};
+};
+const ClusterProvider = () => Provider.succeed(ClusterState, {
+	stables: [
+		"name",
+		"volumeName",
+		"kubeconfigPath"
+	],
+	read: ({ fqn, olds }) => Effect.tryPromise({
+		try: () => observe(fqn, olds),
+		catch: (cause) => new Error(`Unable to inspect local K3s cluster ${olds.name}`, { cause })
+	}),
+	diff: ({ news, olds, output }) => Effect.tryPromise({
+		try: async () => {
+			if (output === void 0) return void 0;
+			if (!isResolved(news)) return void 0;
+			if (typeof news.name === "string" && news.name !== output.name) return {
+				action: "replace",
+				deleteFirst: true
+			};
+			if (typeof news.configFingerprint === "string" && news.configFingerprint !== output.configFingerprint) return { action: "update" };
+			if (typeof news.k3s !== "object" || !("channel" in news.k3s)) return void 0;
+			const desired = await resolveChannelVersion(news.k3s.channel);
+			if (news.k3s.channel === olds.k3s.channel) assertSameMinor(output.currentVersion, desired);
+			if (output.currentVersion === desired) return { action: "noop" };
+			if (!isInsideUpdateWindow(news.k3s.updateWindow)) {
+				console.warn(`K3s ${desired} is available for ${output.name}; update deferred until the configured maintenance window`);
+				return { action: "noop" };
+			}
+			return { action: "update" };
+		},
+		catch: (cause) => new Error("Unable to plan local K3s update", { cause })
+	}),
+	reconcile: ({ fqn, news, olds, output }) => Effect.tryPromise({
+		try: async () => {
+			await requireK3d();
+			const desired = await resolveChannelVersion(news.k3s.channel);
+			if (output !== void 0 && olds?.k3s.channel === news.k3s.channel) assertSameMinor(output.currentVersion, desired);
+			const existing = await inspectK3dCluster(news);
+			const recreate = existing !== void 0 && (await runningVersion(news, existing) !== desired || output?.configFingerprint !== news.configFingerprint);
+			if (recreate) await deleteK3dCluster(news);
+			if (existing === void 0 || recreate) await createK3dCluster(news, desired, output === void 0 ? void 0 : Redacted.value(output.token));
+			const observed = await observe(fqn, news);
+			if (observed === void 0) throw new Error("k3d cluster was not visible after creation");
+			return observed;
+		},
+		catch: (cause) => new Error(`Failed to reconcile local K3s cluster ${news.name}`, { cause })
+	}),
+	delete: ({ olds }) => Effect.tryPromise({
+		try: async () => {
+			if (await inspectK3dCluster(olds) !== void 0) await deleteK3dCluster(olds);
+		},
+		catch: (cause) => new Error(`Failed to delete local K3s cluster ${olds.name}`, { cause })
+	})
+});
+//#endregion
+//#region src/cluster.ts
+const clusterName = (id) => {
+	const name = id.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+	if (name.length === 0) throw new Error("Cluster id must contain a letter or number");
+	return name;
+};
+const validPort = (port) => Number.isInteger(port) && port >= 1 && port <= 65535;
+const Cluster = (id, props) => Effect.gen(function* () {
+	const k3s = normalizeK3sDefinition(props.k3s);
+	if (props.apiPort !== void 0 && !validPort(props.apiPort)) throw new Error("apiPort must be an integer between 1 and 65535");
+	for (const mapping of props.ports ?? []) if (!validPort(mapping.hostPort) || !validPort(mapping.containerPort)) throw new Error("Every local port mapping must use ports between 1 and 65535");
+	const volume = yield* Docker.Volume(`${id}-data`, {
+		...props.context === void 0 ? {} : { context: props.context },
+		labels: { "k3s.cluster": clusterName(id) }
+	});
+	const ports = props.ports ?? [];
+	return yield* ClusterState(id, {
+		name: clusterName(id),
+		k3s,
+		...props.context === void 0 ? {} : { context: props.context },
+		...props.apiPort === void 0 ? {} : { apiPort: props.apiPort },
+		ports,
+		volume,
+		configFingerprint: JSON.stringify({
+			apiPort: props.apiPort,
+			ports,
+			clusterCidr: k3s.clusterCidr,
+			serviceCidr: k3s.serviceCidr,
+			clusterDns: k3s.clusterDns,
+			addons: k3s.addons
+		})
+	});
+});
+//#endregion
+//#region src/providers.ts
+var Providers = class extends Provider.ProviderCollection()("DockerK3s") {};
+const providers = () => Layer.effect(Providers, Provider.collection([ClusterState])).pipe(Layer.provide(ClusterProvider()));
+//#endregion
+export { Cluster, ClusterState, Providers, providers };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "alchemy-docker-k3s",
+  "version": "0.1.0-alpha.0",
+  "description": "Persistent local k3d clusters for Alchemy",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toolbar23/alchemy-k3s.git",
+    "directory": "packages/docker"
+  },
+  "homepage": "https://github.com/toolbar23/alchemy-k3s#readme",
+  "bugs": "https://github.com/toolbar23/alchemy-k3s/issues",
+  "keywords": [
+    "alchemy",
+    "docker",
+    "k3d",
+    "k3s",
+    "kubernetes",
+    "iac"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepack": "npm run build"
+  },
+  "peerDependencies": {
+    "alchemy": ">=2.0.0-beta.74 <3",
+    "effect": ">=4.0.0-rc.110 <5"
+  },
+  "dependencies": {
+    "yaml": "^2.8.1"
+  }
+}