@geekmidas/cli 10.0.0-alpha.77 → 10.0.0-alpha.79

package/dist/{compose-CePlrbUw.cjs → compose-CtUP07r3.cjs}

@@ -2,12 +2,12 @@ const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
 const require_run = require("./run-fVZ-rLnc.cjs");
 const require_discover = require("./discover-D1It5r_h.cjs");
 const require_derive = require("./derive-DAbo49sm.cjs");
-const require_workspace = require("./workspace-DOm81oUo.cjs");
+const require_workspace = require("./workspace-Bp8FEkF-.cjs");
 const require_define = require("./define-DzRz8FgH.cjs");
-const require_stale = require("./stale-yu2FkH3G.cjs");
+const require_seeds = require("./seeds-qX13ubmO.cjs");
 const require_SubscriberGenerator = require("./SubscriberGenerator-CajwOa5W.cjs");
 const require_drivers = require("./drivers-BdvtCKc7.cjs");
-const require_databases = require("./databases-C2p5LGAp.cjs");
+const require_databases = require("./databases-BY-pEImp.cjs");
 const require_credentialSchemas = require("./credentialSchemas-DCR4Wd1W.cjs");
 let node_path = require("node:path");
 let node_fs = require("node:fs");
@@ -49,6 +49,27 @@ function runOptions(stack, env) {
 		...stack.signal ? { signal: stack.signal } : {}
 	};
 }
+/**
+* The host ports a `docker ps` Ports column publishes: `0.0.0.0:443->443/tcp,
+* [::]:443->443/tcp, 0.0.0.0:9000-9001->9000-9001/tcp`.
+*/
+function publishedPorts(column) {
+	const ports = /* @__PURE__ */ new Set();
+	for (const match of column.matchAll(/(?:[\d.]+|\[[^\]]*\]):(\d+)(?:-(\d+))?->/g)) {
+		const first = Number(match[1]);
+		const last = match[2] ? Number(match[2]) : first;
+		for (let port = first; port <= last; port++) ports.add(port);
+	}
+	return [...ports];
+}
+/** Each line `docker ps` printed, as the containers holding `port`. */
+function portHolders(output, port) {
+	return output.split("\n").filter(Boolean).map((line) => line.split("	")).filter(([, , , column = ""]) => publishedPorts(column).includes(port)).map(([container = "", project, service]) => ({
+		container,
+		...project ? { project } : {},
+		...service ? { service } : {}
+	}));
+}
 /** How long a stack has to pass its health checks. */
 const WAIT_TIMEOUT_S = 180;
 /** `docker compose port` printed nothing a port can be read from. */
@@ -249,8 +270,389 @@ const dockerCompose = {
 			if (match) return match.slice(repository.length + 1);
 		} catch {}
 		return id || void 0;
+	},
+	async ensureNetwork(name) {
+		const { code } = await capture("docker", [
+			"network",
+			"inspect",
+			name
+		]);
+		if (code === 0) return;
+		const created = await capture("docker", [
+			"network",
+			"create",
+			name
+		]);
+		if (created.code !== 0 && !/already exists/.test(created.stderr)) throw new NetworkCreateFailed(name, created.stderr);
+	},
+	async publishers(port) {
+		const { stdout } = await capture("docker", [
+			"ps",
+			"--format",
+			"{{.Names}}	{{.Label \"com.docker.compose.project\"}}	{{.Label \"com.docker.compose.service\"}}	{{.Ports}}"
+		]);
+		return portHolders(stdout, port);
 	}
 };
+/** `docker network create` failed. */
+var NetworkCreateFailed = class extends Error {
+	network;
+	output;
+	constructor(network, output) {
+		super(`Could not create the Docker network '${network}' (docker said: ${output.trim() || "nothing"}). Create it by hand with \`docker network create ${network}\` and run again.`);
+		this.network = network;
+		this.output = output;
+		this.name = "NetworkCreateFailed";
+	}
+};
+//#endregion
+//#region src/compose/traefik.ts
+/**
+* The server's shared edge, rendered for Traefik: what the edge itself runs
+* with, and what one stack registers with it.
+*
+* One Traefik per server owns 80 and 443, the ACME state and the redirect to
+* HTTPS. It is configured through its file provider alone: each stack writes
+* one file — its routers, services and middlewares, every name prefixed with
+* its compose project — into a directory the edge watches, and removes it
+* when it stops. There is no Docker socket: the edge never learns what runs
+* on the server except from those files.
+*
+* The edge and the stacks meet on one external Docker network. Only a
+* stack's public services join it, each under an alias prefixed with its
+* project (`<project>-api`), because the network is shared: a bare service
+* name there would be answered by every stack's `api`.
+*
+* Pure: the documents are data, and the edge's side effects are `edge.ts`'s.
+*/
+/**
+* The image, pinned: the edge is every stack's way in, so a new version is a
+* change to this line, not whatever `latest` is on the day a server starts.
+*/
+const TRAEFIK_IMAGE = "traefik:v3.7.13";
+/** The edge's compose project, one per server. */
+const EDGE_PROJECT = "gkm-edge";
+/** The external network the edge and every stack's public services share. */
+const EDGE_NETWORK = "gkm-edge";
+/** The edge's compose service. */
+const EDGE_SERVICE = "traefik";
+/** Inside the edge's container: what it watches, and where certificates are. */
+const EDGE_DYNAMIC_DIR = "/etc/gkm-edge/dynamic";
+const EDGE_CERTS_DIR = "/etc/gkm-edge/certs";
+/** The certificate resolver every deployed route without its own certificate uses. */
+const ACME_RESOLVER = "letsencrypt";
+/** The internal entrypoint the edge's health check asks; never published. */
+const PING_PORT = 8082;
+/** A stack's service, as the edge — and the stack itself — reach it. */
+function edgeAlias(project, service) {
+	return `${project}-${service}`;
+}
+/** A stack's certificate, as the edge's container reads it. */
+function edgeCertificatePaths(project) {
+	return {
+		certFile: `${EDGE_CERTS_DIR}/${project}.crt`,
+		keyFile: `${EDGE_CERTS_DIR}/${project}.key`
+	};
+}
+/**
+* The edge's static configuration: the entrypoints, the redirect, ACME, and
+* the directory it watches. No API and no dashboard — nothing about the edge
+* is reachable but the routes stacks register.
+*/
+function traefikStatic(ports) {
+	return {
+		global: {
+			checkNewVersion: false,
+			sendAnonymousUsage: false
+		},
+		entryPoints: {
+			web: {
+				address: ":80",
+				http: { redirections: { entryPoint: {
+					to: ports.https === 443 ? "websecure" : `:${ports.https}`,
+					scheme: "https",
+					permanent: true
+				} } }
+			},
+			websecure: { address: ":443" },
+			ping: { address: `:${PING_PORT}` }
+		},
+		ping: { entryPoint: "ping" },
+		providers: { file: {
+			directory: EDGE_DYNAMIC_DIR,
+			watch: true
+		} },
+		certificatesResolvers: { [ACME_RESOLVER]: { acme: {
+			storage: "/acme/acme.json",
+			httpChallenge: { entryPoint: "web" }
+		} } },
+		log: { level: "INFO" }
+	};
+}
+/** The edge's compose document. */
+function edgeCompose(options) {
+	const { dir, ports } = options;
+	return {
+		name: EDGE_PROJECT,
+		services: { [EDGE_SERVICE]: {
+			image: TRAEFIK_IMAGE,
+			restart: "unless-stopped",
+			ports: [`${ports.https}:443`, `${ports.http}:80`],
+			volumes: [
+				`${dir}/traefik.yml:/etc/traefik/traefik.yml:ro`,
+				`${dir}/dynamic:${EDGE_DYNAMIC_DIR}:ro`,
+				`${dir}/certs:${EDGE_CERTS_DIR}:ro`,
+				"acme:/acme"
+			],
+			labels: { "dev.geekmidas.edge.config": (0, node_crypto.createHash)("sha256").update(options.staticConfig).digest("hex").slice(0, 16) },
+			networks: ["edge"],
+			healthcheck: {
+				test: [
+					"CMD",
+					"traefik",
+					"healthcheck",
+					"--ping"
+				],
+				interval: "10s",
+				timeout: "5s",
+				retries: 5
+			},
+			logging: options.logging
+		} },
+		volumes: { acme: {} },
+		networks: { edge: {
+			name: EDGE_NETWORK,
+			external: true
+		} }
+	};
+}
+/** A stack's dynamic configuration, as an object. */
+function traefikDynamic(routes, options) {
+	const { project, tls } = options;
+	const name = (route, suffix) => `${project}-${route.name}${suffix ? `-${suffix}` : ""}`;
+	const url = ({ service, port }) => `http://${edgeAlias(project, service)}:${port}`;
+	const routers = {};
+	const services = {};
+	const middlewares = {};
+	for (const route of routes) {
+		const chain = [];
+		if (route.allow) {
+			middlewares[name(route, "allow")] = { ipAllowList: { sourceRange: [...route.allow] } };
+			chain.push(name(route, "allow"));
+		}
+		if (route.prefix) {
+			middlewares[name(route, "prefix")] = { addPrefix: { prefix: route.prefix } };
+			chain.push(name(route, "prefix"));
+		}
+		routers[name(route)] = {
+			rule: `Host(\`${route.host}\`)`,
+			entryPoints: ["websecure"],
+			service: name(route),
+			...chain.length > 0 ? { middlewares: chain } : {},
+			tls: tls.kind === "acme" ? { certResolver: ACME_RESOLVER } : {}
+		};
+		services[name(route)] = { loadBalancer: {
+			servers: route.upstreams.map((upstream) => ({ url: url(upstream) })),
+			...route.prefix ? { passHostHeader: false } : {},
+			...route.streaming ? { responseForwarding: { flushInterval: "-1ms" } } : {},
+			...route.health ? { healthCheck: {
+				path: route.health,
+				interval: "5s",
+				timeout: "3s"
+			} } : {}
+		} };
+	}
+	return {
+		http: {
+			routers,
+			services,
+			...Object.keys(middlewares).length > 0 ? { middlewares } : {}
+		},
+		...tls.kind === "files" ? { tls: { certificates: [{
+			certFile: tls.certFile,
+			keyFile: tls.keyFile
+		}] } } : {}
+	};
+}
+/** A stack's dynamic configuration file, as written to the edge's directory. */
+function traefikDynamicFile(routes, options) {
+	return `# Generated by gkm compose for ${options.project} — do not edit.
+# The shared edge (${EDGE_PROJECT}) reads every file in this directory; this
+# one is removed by gkm compose --down.
+${yaml$1(traefikDynamic(routes, options))}`;
+}
+/** The edge's static configuration file. */
+function traefikStaticFile(ports) {
+	return `# Generated by gkm compose — the server's shared edge. Do not edit.
+${yaml$1(traefikStatic(ports))}`;
+}
+/** The edge's compose file. */
+function edgeComposeFile(options) {
+	return `# Generated by gkm compose — the server's shared edge. Do not edit.
+#
+# Started by the first stack that runs with proxy: 'traefik', and left
+# running by gkm compose --down. Stop it, once nothing uses it, with:
+#
+#   docker compose -p ${EDGE_PROJECT} -f ${options.dir}/docker-compose.yml down
+${yaml$1(edgeCompose(options))}`;
+}
+function yaml$1(value) {
+	return (0, yaml.stringify)(value, {
+		lineWidth: 0,
+		aliasDuplicateObjects: false
+	});
+}
+//#endregion
+//#region src/compose/edge.ts
+/**
+* The server's shared Traefik edge, on disk and in Docker: started when a
+* stack needs it, and each stack's routes written to — and removed from —
+* the directory it watches.
+*
+* The edge lives in the deploy user's gkm home (`$GKM_HOME/edge`, else
+* `~/.gkm/edge`): the user who runs `gkm compose` owns it, so nothing needs
+* root, and it sits beside the stage keys that same user already keeps.
+*
+*   ~/.gkm/edge/
+*     docker-compose.yml   the edge's compose project (gkm-edge)
+*     traefik.yml          its static configuration
+*     dynamic/<project>.yml  one per stack: its routers, services, middlewares
+*     certs/<project>.crt|.key  a stack's own certificate, where it has one
+*/
+/** The edge's directory on this machine. */
+function edgeDir(env = process.env) {
+	return (0, node_path.join)(require_run.gkmHome(env), "edge");
+}
+/** The edge's compose project, as docker is asked about it. */
+function edgeRef(dir, options = {}) {
+	return {
+		project: EDGE_PROJECT,
+		file: (0, node_path.join)(dir, "docker-compose.yml"),
+		cwd: dir,
+		...options
+	};
+}
+/**
+* Something other than the proxy a stack is set to holds the edge's ports.
+*
+* With `proxy: 'traefik'`, the stack's own Caddy — still running from before
+* the switch — or any other container; with `proxy: 'caddy'`, the shared
+* edge, or another stack's Caddy. Refused before anything is started, so the
+* stack is never left half on one proxy and half on the other.
+*/
+var ComposeProxyClash = class extends Error {
+	project;
+	proxy;
+	port;
+	holder;
+	constructor(project, proxy, port, holder) {
+		const by = holder.project ? `${holder.container} (compose project ${holder.project})` : holder.container;
+		const fix = proxy === "traefik" ? holder.project === project && holder.service === "caddy" ? `That is this stack's own Caddy, from before it was switched to proxy: 'traefik'. Move it once: stop it (docker compose -p ${project} stop caddy), then run gkm compose again — the shared edge takes 80/443 and the stack registers with it.` : `The shared edge needs ports 80 and 443. Stop ${holder.container}${holder.project ? ` (docker compose -p ${holder.project} down, or its own gkm compose --down)` : ""}, or move the edge with GKM_COMPOSE_HTTPS_PORT/GKM_COMPOSE_HTTP_PORT.` : holder.project === "gkm-edge" ? `That is the server's shared Traefik edge, which other stacks register with. Set deploy.compose.proxy to 'traefik' for this stage so the stack registers with it too, or stop the edge once nothing uses it (docker compose -p ${EDGE_PROJECT} down).` : `Stop ${holder.container}, or publish this stack's Caddy elsewhere with GKM_COMPOSE_HTTPS_PORT/GKM_COMPOSE_HTTP_PORT.`;
+		super(`${project} is set to proxy: '${proxy}', and port ${port} is held by ${by}. ${fix}`);
+		this.project = project;
+		this.proxy = proxy;
+		this.port = port;
+		this.holder = holder;
+		this.name = "ComposeProxyClash";
+	}
+};
+/**
+* Refuse a stack whose edge ports are held by anything but its own proxy:
+* the shared edge for `'traefik'`, the stack's own Caddy for `'caddy'`.
+*/
+async function assertEdgePorts(docker, options) {
+	const { project, proxy, ports } = options;
+	for (const port of [ports.https, ports.http]) for (const holder of await docker.publishers(port)) if (!(proxy === "traefik" ? holder.project === "gkm-edge" : holder.project === project && holder.service === "caddy")) throw new ComposeProxyClash(project, proxy, port, holder);
+}
+/** Write a file whole or not at all: a temporary file, then a rename. */
+async function writeAtomic(path, content, mode = 420) {
+	const temporary = `${path}.${process.pid}.tmp`;
+	await (0, node_fs_promises.writeFile)(temporary, content, { mode });
+	await (0, node_fs_promises.chmod)(temporary, mode);
+	await (0, node_fs_promises.rename)(temporary, path);
+}
+/** Write a file only when its content changed; whether it did. */
+async function writeIfChanged(path, content) {
+	if (await (0, node_fs_promises.readFile)(path, "utf-8").catch(() => void 0) === content) return false;
+	await writeAtomic(path, content);
+	return true;
+}
+/**
+* The edge, up: its network, its files, and its container — started when it
+* is not running, and recreated when its configuration changed. Idempotent:
+* on a server where it already runs as configured, `up` changes nothing.
+*/
+async function ensureEdge(docker, options) {
+	const { dir, ports } = options;
+	await (0, node_fs_promises.mkdir)((0, node_path.join)(dir, "dynamic"), { recursive: true });
+	await (0, node_fs_promises.mkdir)((0, node_path.join)(dir, "certs"), {
+		recursive: true,
+		mode: 448
+	});
+	const staticConfig = traefikStaticFile(ports);
+	await writeIfChanged((0, node_path.join)(dir, "traefik.yml"), staticConfig);
+	await writeIfChanged((0, node_path.join)(dir, "docker-compose.yml"), edgeComposeFile({
+		dir,
+		ports,
+		staticConfig,
+		logging: options.logging
+	}));
+	await docker.ensureNetwork(EDGE_NETWORK);
+	await docker.up(edgeRef(dir, {
+		...options.output ? { output: options.output } : {},
+		...options.signal ? { signal: options.signal } : {}
+	}), [EDGE_SERVICE]);
+	return [(0, node_path.join)(dir, "traefik.yml"), (0, node_path.join)(dir, "docker-compose.yml")];
+}
+/** A stack's file in the edge's directory. */
+function routesFile(dir, project) {
+	return (0, node_path.join)(dir, "dynamic", `${project}.yml`);
+}
+/**
+* Register a stack with the edge: its certificate first, where it has one,
+* so the routes that need it never load without it — then its routes, in one
+* rename the edge picks up whole.
+*/
+async function writeEdgeRoutes(dir, project, routes, certificate) {
+	const files = [];
+	if (certificate) {
+		const certs = (0, node_path.join)(dir, "certs");
+		await (0, node_fs_promises.mkdir)(certs, {
+			recursive: true,
+			mode: 448
+		});
+		const crt = (0, node_path.join)(certs, `${project}.crt`);
+		const key = (0, node_path.join)(certs, `${project}.key`);
+		await (0, node_fs_promises.copyFile)(certificate.certFile, `${crt}.tmp`);
+		await (0, node_fs_promises.rename)(`${crt}.tmp`, crt);
+		await (0, node_fs_promises.copyFile)(certificate.keyFile, `${key}.tmp`);
+		await (0, node_fs_promises.chmod)(`${key}.tmp`, 384);
+		await (0, node_fs_promises.rename)(`${key}.tmp`, key);
+		files.push(crt, key);
+	} else await removeCertificate(dir, project);
+	await (0, node_fs_promises.mkdir)((0, node_path.join)(dir, "dynamic"), { recursive: true });
+	const file = routesFile(dir, project);
+	await writeAtomic(file, routes);
+	files.push(file);
+	return files;
+}
+/** What a stack's file holds for the moment between emptying and removal. */
+const UNREGISTERED = "# Unregistered by gkm compose --down.\n";
+async function removeCertificate(dir, project) {
+	for (const ext of ["crt", "key"]) await (0, node_fs_promises.rm)((0, node_path.join)(dir, "certs", `${project}.${ext}`), { force: true });
+}
+/**
+* Unregister a stack: its routes, then its certificate. Whether there was
+* anything to remove.
+*/
+async function removeEdgeRoutes(dir, project) {
+	const file = routesFile(dir, project);
+	const existed = (0, node_fs.existsSync)(file);
+	if (existed) await writeAtomic(file, UNREGISTERED);
+	await (0, node_fs_promises.rm)(file, { force: true });
+	await removeCertificate(dir, project);
+	return existed;
+}
 //#endregion
 //#region src/compose/images.ts
 /**
@@ -496,9 +898,9 @@ function otlpHeaders(email, password) {
 /** The stack's OpenObserve for one stage. */
 function stackLogs(options) {
 	const { config, stage, local, custom } = options;
-	const conflicting = Object.keys(custom).filter(require_stale.isOtlpDestination).sort();
+	const conflicting = Object.keys(custom).filter(require_seeds.isOtlpDestination).sort();
 	if (conflicting.length > 0) throw new LogsEndpointConflict(stage, conflicting);
-	if (!local && !options.domain) throw new require_stale.NoDomainForStage(stage);
+	if (!local && !options.domain) throw new require_seeds.NoDomainForStage(stage);
 	const email = custom["ZO_ROOT_USER_EMAIL"] ?? (local ? "admin@gkm.localhost" : `admin@${options.domain}`);
 	const set = custom[LOGS_PASSWORD_KEY];
 	if (!set && !local) throw new LogsPasswordMissing(stage);
@@ -596,7 +998,7 @@ const REDIS_SERVICE = "redis";
 /** The port it answers on, inside the network. */
 const REDIS_PORT = 6379;
 /** Reconcile's pin, so `gkm dev` and the stack run one Redis. */
-const REDIS_IMAGE = require_stale.DEFAULT_IMAGES.redis;
+const REDIS_IMAGE = require_seeds.DEFAULT_IMAGES.redis;
 /**
 * How much it may hold before it evicts. A cache that grows until the box
 * runs out of memory takes the apps with it; 256 MB is a lot of sessions and
@@ -715,9 +1117,16 @@ function redisService(redis) {
 }
 //#endregion
 //#region src/compose/caddyfile.ts
+/** Where Caddy reads a stage's own certificate, inside its container. */
+const CADDY_TLS_DIR = "/etc/caddy/tls";
+/** An upstream on the stack's own network: its service name. */
+function address({ service, port }) {
+	return `${service}:${port}`;
+}
 /** The Caddyfile for a stack's edge. */
-function edgeCaddyfile(sites, options) {
-	const global = options.local ? `{
+function edgeCaddyfile(routes, options) {
+	const { tls } = options;
+	const global = tls.kind === "internal" ? `{
 	# No ACME and no public DNS: the CA is Caddy's own and the names resolve
 	# to this machine.
 	local_certs
@@ -725,27 +1134,30 @@ function edgeCaddyfile(sites, options) {
 }` : options.email ? `{
 	email ${options.email}
 }` : "";
-	const blocks = sites.map(({ host, upstream, rewrite, allow }) => `https://${host} {${options.local ? `
+	const certificate = tls.kind === "internal" ? `
 	tls internal
-` : ""}${allow ? `
+` : tls.kind === "files" ? `
+	tls ${tls.certFile} ${tls.keyFile}
+` : "";
+	const blocks = routes.map(({ host, upstreams, prefix, allow, streaming }) => `https://${host} {${certificate}${allow ? `
 	# Only these addresses — the peer Caddy sees, never a header a client
 	# could set. Everything else is refused before it reaches the upstream.
 	@denied not remote_ip ${allow.join(" ")}
 	respond @denied 403
-` : ""}${rewrite ? `
+` : ""}${prefix ? `
 	# A bucket, served at a host of its own: the bucket is a prefix on MinIO,
 	# which routes and signs on the Host header — so it is sent the upstream's.
-	reverse_proxy ${upstream} {
-		rewrite ${rewrite}
+	reverse_proxy ${upstreams.map(address).join(" ")} {
+		rewrite ${prefix}{uri}
 		header_up Host {upstream_hostport}
 	}` : `
 	# Host and X-Forwarded-* are passed through as Caddy does by default, so
 	# an app builds redirects, cookies and links on the address a caller used.
-	reverse_proxy ${upstream} {
+	reverse_proxy ${upstreams.map(address).join(" ")}${streaming ? ` {
 		# Never buffer: a streamed response — server-sent events, a Next.js
 		# RSC payload — reaches the client as each chunk is written.
 		flush_interval -1
-	}`}
+	}` : ""}`}
 }`);
 	return `${HEADER}${global ? `${global}\n\n` : ""}${blocks.join("\n\n")}\n`;
 }
@@ -907,7 +1319,9 @@ function composeStack(input) {
 	const custom = input.secrets?.custom ?? {};
 	const https = input.ports?.https ?? 443;
 	const http = input.ports?.http ?? 80;
-	const plan = require_stale.planFor(manifest, stage, (0, _geekmidas_manifest.provisionOrder)(manifest), {
+	const proxy = require_workspace.proxyFor(workspace.deploy?.compose, stage, local);
+	const certificate = local ? void 0 : require_workspace.certificateFor(workspace.deploy?.compose, stage, workspace.root);
+	const plan = require_seeds.planFor(manifest, stage, (0, _geekmidas_manifest.provisionOrder)(manifest), {
 		localStage: workspace.stages.local,
 		events: require_SubscriberGenerator.DEFAULT_EVENTS.server,
 		cache: STACK_CACHE,
@@ -917,7 +1331,7 @@ function composeStack(input) {
 	const seed = local ? void 0 : input.secrets?.seed;
 	if (!local && !seed) throw new StageSeedMissing(stage);
 	const credential = {
-		master: local ? "geekmidas" : require_stale.localRolePassword(workspace.name, plan, "master", seed),
+		master: local ? "geekmidas" : require_seeds.localRolePassword(workspace.name, plan, "master", seed),
 		...seed ? { seed } : {}
 	};
 	const apps = stackApps(workspace, manifest, plan, {
@@ -927,7 +1341,7 @@ function composeStack(input) {
 		identity,
 		images: input.images
 	});
-	const workers = stackWorkers(require_stale.workerUnits(workspace, manifest, input.background ?? {}), {
+	const workers = stackWorkers(require_seeds.workerUnits(workspace, manifest, input.background ?? {}), {
 		stage,
 		identity,
 		images: input.images
@@ -945,12 +1359,12 @@ function composeStack(input) {
 	const reads = /* @__PURE__ */ new Map();
 	for (const app of apps) {
 		const site = manifest[app.id];
-		reads.set(app.name, site?.kind === "site" ? Object.values((0, _geekmidas_manifest.publicEnvFor)(site, manifest)) : [...require_stale.appEnvKeys(manifest, app.name, input.runnables) ?? []]);
+		reads.set(app.name, site?.kind === "site" ? Object.values((0, _geekmidas_manifest.publicEnvFor)(site, manifest)) : [...require_seeds.appEnvKeys(manifest, app.name, input.runnables) ?? []]);
 	}
-	for (const worker of workers) reads.set(worker.name, [...require_stale.workerEnvKeys(manifest, worker.id, input.runnables) ?? []]);
+	for (const worker of workers) reads.set(worker.name, [...require_seeds.workerEnvKeys(manifest, worker.id, input.runnables) ?? []]);
 	const domain = workspace.deploy?.domains?.[stage];
 	const logsConfig = require_workspace.resolveLogs(workspace.deploy?.compose?.logs);
-	const logs = logsConfig ? stackLogs({
+	const logsBase = logsConfig ? stackLogs({
 		config: logsConfig,
 		stage,
 		local,
@@ -963,7 +1377,7 @@ function composeStack(input) {
 		missing: [],
 		minio: plan.resources.filter((r) => r.kind === "objects").map((r) => r.id),
 		mailpit: plan.resources.filter((r) => r.kind === "email").map((r) => r.id)
-	} : require_stale.assertExternalServices({
+	} : require_seeds.assertExternalServices({
 		stage,
 		declarations: serviceDeclarations(plan, reads, owners),
 		supplied: custom,
@@ -976,30 +1390,16 @@ function composeStack(input) {
 		local,
 		custom
 	});
-	const infra = [...plan.containers.filter((c) => !NOT_RUN[c]).filter((c) => c !== "minio" || services.minio.length > 0).filter((c) => c !== "mailpit" || services.mailpit.length > 0).filter((c) => c !== "redis" || redis !== void 0), ...logs ? [LOGS_SERVICE] : []].sort();
+	const infra = [...plan.containers.filter((c) => !NOT_RUN[c]).filter((c) => c !== "minio" || services.minio.length > 0).filter((c) => c !== "mailpit" || services.mailpit.length > 0).filter((c) => c !== "redis" || redis !== void 0), ...logsBase ? [LOGS_SERVICE] : []].sort();
 	const storage = infra.includes("minio") ? (() => {
 		const buckets = services.minio.map((id) => byId.get(id)?.name).filter((name) => Boolean(name)).sort();
 		return {
 			user: custom.AWS_ACCESS_KEY_ID ?? (local ? "geekmidas" : `${workspace.name}-minio`),
-			password: custom.AWS_SECRET_ACCESS_KEY ?? (local ? "geekmidas" : require_stale.localRolePassword(workspace.name, plan, "minio", seed)),
+			password: custom.AWS_SECRET_ACCESS_KEY ?? (local ? "geekmidas" : require_seeds.localRolePassword(workspace.name, plan, "minio", seed)),
 			buckets,
-			policies: require_stale.bucketPolicies(plan).filter((p) => buckets.includes(p.bucket))
+			policies: require_seeds.bucketPolicies(plan).filter((p) => buckets.includes(p.bucket))
 		};
 	})() : void 0;
-	const derivation = {
-		project: workspace.name,
-		master: credential.master,
-		...credential.seed ? { seed: credential.seed } : {},
-		...!local && domain ? { mailFrom: `noreply@${domain}` } : {}
-	};
-	const outside = require_stale.networkEnv(plan, {
-		...derivation,
-		addresses: Object.fromEntries(apps.map((app) => [app.id, app.url]))
-	});
-	const inside = require_stale.networkEnv(plan, {
-		...derivation,
-		addresses: Object.fromEntries(apps.map((app) => [app.id, `http://${app.name}:${app.port}`]))
-	});
 	const fileServers = /* @__PURE__ */ new Map();
 	if (storage) for (const resource of plan.resources) {
 		if (resource.kind !== "file-server" || !resource.of) continue;
@@ -1008,20 +1408,52 @@ function composeStack(input) {
 		const bucket = byId.get(resource.of);
 		if (!bucket) continue;
 		let host;
-		if (local) host = require_stale.hostFor(resource, workspace.name);
+		if (local) host = require_seeds.hostFor(resource, workspace.name);
 		else {
-			if (!domain) throw new require_stale.NoDomainForStage(stage);
+			if (!domain) throw new require_seeds.NoDomainForStage(stage);
 			host = `${resource.subdomain ?? require_derive.appKey(resource.id)}.${domain}`;
 		}
 		fileServers.set(resource.id, {
 			url: `https://${host}${local && https !== 443 ? `:${https}` : ""}`,
-			site: {
+			route: {
+				name: `files-${require_derive.appKey(resource.id)}`,
 				host,
-				upstream: "minio:9000",
-				rewrite: `/${bucket.name}{uri}`
+				upstreams: [{
+					service: "minio",
+					port: 9e3
+				}],
+				streaming: false,
+				prefix: `/${bucket.name}`
 			}
 		});
 	}
+	const edgeServices = new Set(proxy === "traefik" ? [
+		...apps.map((app) => app.name),
+		...fileServers.size > 0 ? ["minio"] : [],
+		...logsBase?.host && logsBase.public ? [LOGS_SERVICE] : []
+	] : []);
+	const hostOf = (service) => edgeServices.has(service) ? edgeAlias(project, service) : service;
+	const logs = logsBase && {
+		...logsBase,
+		appEnv: {
+			...logsBase.appEnv,
+			OTEL_EXPORTER_OTLP_ENDPOINT: logsBase.appEnv.OTEL_EXPORTER_OTLP_ENDPOINT.replace(`//openobserve:`, `//${hostOf("openobserve")}:`)
+		}
+	};
+	const derivation = {
+		project: workspace.name,
+		master: credential.master,
+		...credential.seed ? { seed: credential.seed } : {},
+		...!local && domain ? { mailFrom: `noreply@${domain}` } : {}
+	};
+	const outside = require_seeds.networkEnv(plan, {
+		...derivation,
+		addresses: Object.fromEntries(apps.map((app) => [app.id, app.url]))
+	}, hostOf);
+	const inside = require_seeds.networkEnv(plan, {
+		...derivation,
+		addresses: Object.fromEntries(apps.map((app) => [app.id, `http://${hostOf(app.name)}:${app.port}`]))
+	}, hostOf);
 	const surfaceUrls = new Map(plan.resources.filter((r) => r.kind === "rest-api" || r.kind === "site").map((r) => [r.envKey, r.id]));
 	const appById = new Map(apps.map((app) => [app.id, app]));
 	/**
@@ -1034,7 +1466,7 @@ function composeStack(input) {
 			if (owner.kind === "file-server") return fileServers.get(owner.id)?.url;
 			return outside[key];
 		}
-		if (owner && require_stale.suppliedOnly(owner.kind, owner.id, key, local)) {
+		if (owner && require_seeds.suppliedOnly(owner.kind, owner.id, key, local)) {
 			const value = custom[key];
 			if (value === void 0) throw new StageSecretMissing(app.name, key, stage);
 			return value;
@@ -1074,17 +1506,17 @@ function composeStack(input) {
 			continue;
 		}
 		if (input.buildOnly) continue;
-		const keys = require_stale.appEnvKeys(manifest, app.name, input.runnables) ?? /* @__PURE__ */ new Set();
+		const keys = require_seeds.appEnvKeys(manifest, app.name, input.runnables) ?? /* @__PURE__ */ new Set();
 		const values = valuesFor(app, keys);
 		const trusted = (0, _geekmidas_manifest.provideKey)(app.id, "trustedOrigins");
 		if (keys.has(trusted)) {
-			const internal = (byId.get(app.id)?.callers ?? []).map((caller) => appById.get(caller)).filter((caller) => caller?.kind === "rest-api").map((caller) => `http://${caller.name}:${caller.port}`);
+			const internal = (byId.get(app.id)?.callers ?? []).map((caller) => appById.get(caller)).filter((caller) => caller?.kind === "rest-api").map((caller) => `http://${hostOf(caller.name)}:${caller.port}`);
 			const origins = [...(values[trusted] ?? "").split(",").filter(Boolean), ...internal];
 			values[trusted] = [...new Set(origins)].join(",");
 		}
 		app.env = {
 			...values,
-			...require_stale.otelEnv({
+			...require_seeds.otelEnv({
 				...custom,
 				...logs?.appEnv
 			}, app.name),
@@ -1095,14 +1527,14 @@ function composeStack(input) {
 		for (const [key, value] of Object.entries(app.env)) if (/[\r\n]/.test(value)) throw new EnvValueMultiline(app.name, key);
 	}
 	for (const worker of input.buildOnly ? [] : workers) {
-		const keys = require_stale.workerEnvKeys(manifest, worker.id, input.runnables) ?? /* @__PURE__ */ new Set();
+		const keys = require_seeds.workerEnvKeys(manifest, worker.id, input.runnables) ?? /* @__PURE__ */ new Set();
 		worker.env = {
 			...valuesFor({
 				name: worker.name,
 				id: worker.id,
 				kind: "rest-api"
 			}, keys),
-			...require_stale.otelEnv({
+			...require_seeds.otelEnv({
 				...custom,
 				...logs?.appEnv
 			}, worker.name),
@@ -1112,6 +1544,14 @@ function composeStack(input) {
 		};
 		for (const [key, value] of Object.entries(worker.env)) if (/[\r\n]/.test(value)) throw new EnvValueMultiline(worker.name, key);
 	}
+	const deployedTls = certificate ? {
+		kind: "files",
+		...proxy === "caddy" ? {
+			certFile: `${CADDY_TLS_DIR}/cert.pem`,
+			keyFile: `${CADDY_TLS_DIR}/key.pem`
+		} : edgeCertificatePaths(project)
+	} : { kind: "acme" };
+	const tls = local ? { kind: "internal" } : deployedTls;
 	const layout = input.layout ?? defaultLayout(workspace.root);
 	const compose = stackFile({
 		project,
@@ -1128,24 +1568,38 @@ function composeStack(input) {
 		composeDir: (0, node_path.join)(workspace.root, stackDir(stage)),
 		buildRoot: layout.buildRoot,
 		workspaceRoot: workspace.root,
-		envFiles: !input.buildOnly
+		envFiles: !input.buildOnly,
+		proxy,
+		edge: new Map([...edgeServices].map((service) => [service, hostOf(service)])),
+		tls: certificate !== void 0
 	});
-	const caddyfile = edgeCaddyfile([
+	const routes = [
 		...apps.map((app) => ({
+			name: app.name,
 			host: app.host,
-			upstream: `${app.name}:${app.port}`
+			upstreams: [{
+				service: app.name,
+				port: app.port
+			}],
+			streaming: true,
+			health: app.kind === "site" ? "/" : "/health"
 		})),
-		...[...fileServers.values()].map(({ site }) => site),
+		...[...fileServers.values()].map(({ route }) => route),
 		...logs?.host && logs.public ? [{
+			name: LOGS_SERVICE,
 			host: logs.host,
-			upstream: `${LOGS_SERVICE}:${require_workspace.LOGS_PORT}`,
+			upstreams: [{
+				service: LOGS_SERVICE,
+				port: require_workspace.LOGS_PORT
+			}],
+			streaming: true,
 			allow: logs.public.allow
 		}] : []
-	], { local });
+	];
 	const dockerfiles = {};
 	for (const app of apps) {
 		if (!app.build) continue;
-		dockerfiles[app.build.dockerfile] = require_stale.appDockerfile(app.name, workspace.apps[app.name], {
+		dockerfiles[app.build.dockerfile] = require_seeds.appDockerfile(app.name, workspace.apps[app.name], {
 			layout,
 			workspaceRoot: workspace.root,
 			apps: workspace.apps,
@@ -1155,7 +1609,7 @@ function composeStack(input) {
 	}
 	for (const worker of workers) {
 		if (!worker.build) continue;
-		dockerfiles[worker.build.dockerfile] = require_stale.workerDockerfile({
+		dockerfiles[worker.build.dockerfile] = require_seeds.workerDockerfile({
 			id: worker.id,
 			name: worker.name,
 			app: worker.host
@@ -1173,12 +1627,18 @@ function composeStack(input) {
 		workers,
 		infra,
 		compose,
-		caddyfile,
+		proxy,
+		routes,
+		...proxy === "caddy" ? { caddyfile: edgeCaddyfile(routes, { tls }) } : { traefik: traefikDynamicFile(routes, {
+			project,
+			tls: deployedTls
+		}) },
+		...certificate ? { tls: certificate } : {},
 		dockerfiles,
 		plan,
 		credential,
 		...storage ? { storage } : {},
-		devServices: local ? [] : require_stale.devServicesUsed(services),
+		devServices: local ? [] : require_seeds.devServicesUsed(services),
 		...logs ? { logs } : {},
 		...redis ? { redis } : {}
 	};
@@ -1239,7 +1699,7 @@ function stackApps(workspace, manifest, plan, options) {
 		if (!app || !resource || !app.port) continue;
 		const host = hostOf(name, app, workspace, resource, options);
 		const tag = declaration.kind === "site" ? siteTag(options.images.tag, options.stage) : options.images.tag;
-		const ref = require_stale.validateImageRef(require_stale.imageRef(options.identity, name, options.images.registry, tag));
+		const ref = require_seeds.validateImageRef(require_seeds.imageRef(options.identity, name, options.images.registry, tag));
 		apps.push({
 			app: name,
 			name,
@@ -1263,8 +1723,8 @@ function stackWorkers(units, options) {
 		name: unit.name,
 		id: unit.id,
 		host: unit.app,
-		port: require_stale.WORKER_PORT,
-		ref: require_stale.validateImageRef(require_stale.imageRef(options.identity, unit.name, options.images.registry, options.images.tag)),
+		port: require_seeds.WORKER_PORT,
+		ref: require_seeds.validateImageRef(require_seeds.imageRef(options.identity, unit.name, options.images.registry, options.images.tag)),
 		tag: options.images.tag,
 		...options.images.mode === "build" ? { build: { dockerfile: `${stackDir(options.stage)}/Dockerfile.${unit.name}` } } : {}
 	}));
@@ -1275,25 +1735,27 @@ function stackWorkers(units, options) {
 * same rule a deploy follows — for any other.
 */
 function hostOf(name, app, workspace, resource, options) {
-	if (options.local) return require_stale.hostFor(resource, workspace.name);
-	return require_stale.resolveHost(name, app, options.stage, workspace.deploy?.domains, require_stale.isMainFrontendApp(name, app, workspace.apps));
+	if (options.local) return require_seeds.hostFor(resource, workspace.name);
+	return require_seeds.resolveHost(name, app, options.stage, workspace.deploy?.domains, require_seeds.isMainFrontendApp(name, app, workspace.apps));
 }
 /** The compose document: the infrastructure, the apps, and the edge. */
 function stackFile(options) {
 	const { project, plan, apps } = options;
 	const infra = options.infra.filter((name) => name !== LOGS_SERVICE);
-	const derived = require_stale.composeFor({
+	const derived = require_seeds.composeFor({
 		...plan,
 		containers: [...infra]
 	}, {
 		project,
-		ports: Object.fromEntries(require_stale.portKeys(infra, plan.fakes).map((key) => [key, 0]))
+		ports: Object.fromEntries(require_seeds.portKeys(infra, plan.fakes).map((key) => [key, 0]))
 	});
 	const services = {};
 	const volumes = {
 		...derived.volumes,
-		"caddy-data": {},
-		"caddy-config": {},
+		...options.proxy === "caddy" ? {
+			"caddy-data": {},
+			"caddy-config": {}
+		} : {},
 		...options.logs ? { "openobserve-data": {} } : {}
 	};
 	for (const name of infra) {
@@ -1325,7 +1787,7 @@ function stackFile(options) {
 	for (const app of apps) services[app.name] = {
 		image: app.ref,
 		...app.build ? { build: {
-			...require_stale.composeBuildPaths({
+			...require_seeds.composeBuildPaths({
 				composeDir: options.composeDir,
 				buildRoot: options.buildRoot,
 				workspaceRoot: options.workspaceRoot,
@@ -1345,7 +1807,7 @@ function stackFile(options) {
 	};
 	for (const worker of options.workers) services[worker.name] = {
 		image: worker.ref,
-		...worker.build ? { build: require_stale.composeBuildPaths({
+		...worker.build ? { build: require_seeds.composeBuildPaths({
 			composeDir: options.composeDir,
 			buildRoot: options.buildRoot,
 			workspaceRoot: options.workspaceRoot,
@@ -1359,14 +1821,15 @@ function stackFile(options) {
 		...infra.length ? { depends_on: Object.fromEntries(infra.map((name) => [name, HEALTHY])) } : {},
 		healthcheck: probe(worker.port, "/health")
 	};
-	services.caddy = {
-		image: require_stale.DEFAULT_IMAGES.caddy,
+	if (options.proxy === "caddy") services.caddy = {
+		image: require_seeds.DEFAULT_IMAGES.caddy,
 		restart: "unless-stopped",
 		ports: [`${options.https}:443`, `${options.http}:80`],
 		volumes: [
 			"./Caddyfile:/etc/caddy/Caddyfile:ro",
 			"caddy-data:/data",
-			"caddy-config:/config"
+			"caddy-config:/config",
+			...options.tls ? [`./tls:${CADDY_TLS_DIR}:ro`] : []
 		],
 		depends_on: Object.fromEntries(apps.map((app) => [app.name, HEALTHY])),
 		healthcheck: {
@@ -1380,6 +1843,14 @@ function stackFile(options) {
 			retries: 5
 		}
 	};
+	for (const [service, alias] of options.edge) {
+		const definition = services[service];
+		if (!definition) continue;
+		definition.networks = {
+			default: { aliases: [alias] },
+			edge: { aliases: [alias] }
+		};
+	}
 	for (const service of Object.values(services)) {
 		if (!options.envFiles) delete service.env_file;
 		service.logging = {
@@ -1390,7 +1861,11 @@ function stackFile(options) {
 	return {
 		name: project,
 		services,
-		volumes
+		volumes,
+		...options.edge.size > 0 ? { networks: { edge: {
+			name: EDGE_NETWORK,
+			external: true
+		} } } : {}
 	};
 }
 /**
@@ -1403,7 +1878,7 @@ function defaultLayout(root) {
 		gkmRoot: ".",
 		tools: {
 			packageManager: "pnpm",
-			turboVersion: require_stale.TURBO_VERSION,
+			turboVersion: require_seeds.TURBO_VERSION,
 			monorepo: true
 		},
 		gkmPaths: ["gkm.config.*"]
@@ -1437,12 +1912,12 @@ var HealthRequestTimedOut = class extends Error {
 	}
 };
 /** The real probe: one HTTPS GET, the certificate verified. */
-const httpsProbe = ({ url, ca, connectTo, timeoutMs, signal }) => {
+const httpsProbe = ({ url, ca, connectTo, connectPort, timeoutMs, signal }) => {
 	const target = new URL(url);
 	return new Promise((resolve, reject) => {
 		const req = (0, node_https.request)({
 			host: connectTo ?? target.hostname,
-			port: target.port || 443,
+			port: connectPort ?? (target.port || 443),
 			servername: target.hostname,
 			path: `${target.pathname}${target.search}`,
 			method: "GET",
@@ -1468,10 +1943,13 @@ function isHealthy(status) {
 var ComposeAppsUnhealthy = class extends Error {
 	project;
 	apps;
-	constructor(project, apps) {
-		super(`${project} started, but ${apps.length === 1 ? "this app does" : "these apps do"} not answer through Caddy:\n` + apps.map(({ url, last }) => `  - ${url}: ${last}`).join("\n") + `\nSee why with \`docker compose -p ${project} logs caddy ${apps.map((a) => a.app).join(" ")}\`.`);
+	proxy;
+	constructor(project, apps, proxy = "caddy") {
+		const names = apps.map((a) => a.app).join(" ");
+		super(`${project} started, but ${apps.length === 1 ? "this app does" : "these apps do"} not answer through ${proxy === "caddy" ? "Caddy" : "the shared Traefik edge"}:\n` + apps.map(({ url, last }) => `  - ${url}: ${last}`).join("\n") + (proxy === "caddy" ? `\nSee why with \`docker compose -p ${project} logs caddy ${names}\`.` : `\nSee why with \`docker compose -p gkm-edge logs traefik\` and \`docker compose -p ${project} logs ${names}\`.`));
 		this.project = project;
 		this.apps = apps;
+		this.proxy = proxy;
 		this.name = "ComposeAppsUnhealthy";
 	}
 };
@@ -1487,8 +1965,9 @@ var ComposeAppsUnhealthy = class extends Error {
 *   is asked of the registry first; one missing image stops the run naming
 *   them all, and nothing is written, pulled or started.
 * - The databases exist before the apps do (`provision`). Postgres comes up
-*   alone, its databases, roles and grants are created and its migrations
-*   applied from this machine, and only then do the apps start — so an app
+*   alone, its databases, roles and grants are created, its migrations
+*   applied and its seeds run from this machine, and only then do the apps
+*   start — so an app
 *   never boots against a schema that is not there yet.
 * - What a stage runs is recorded (`release`). Each app's image, the tag it
 *   was released under and the digest it resolved to are written to the
@@ -1583,9 +2062,10 @@ function edgePorts(env = process.env) {
 const defaultDeps = {
 	docker: dockerCompose,
 	revision: gitRevision,
-	sql: require_stale.pgClient,
-	buckets: require_stale.bucketClient,
+	sql: require_seeds.pgClient,
+	buckets: require_seeds.bucketClient,
 	migrate: require_databases.migrateDatabases,
+	seed: require_databases.seedDatabases,
 	probe: httpsProbe,
 	healthAttempts: 90,
 	healthIntervalMs: 2e3,
@@ -1604,31 +2084,31 @@ async function validateCompose(ctx, deps, options = {}) {
 	if (push && mode !== "build") throw new ComposePushNeedsBuild();
 	if (options.pin && mode !== "pull") throw new ComposePinNeedsPull();
 	const registry = workspace.deploy?.registry;
-	if (!registry && (push || mode === "pull")) throw new RegistryRequired(push ? "push" : "pull", require_stale.imageRef(identity, ctx.apps[0] ?? workspace.name, void 0, tag));
+	if (!registry && (push || mode === "pull")) throw new RegistryRequired(push ? "push" : "pull", require_seeds.imageRef(identity, ctx.apps[0] ?? workspace.name, void 0, tag));
 	const runnables = {};
 	const background = {};
 	const manifest = await require_discover.discover({
-		patterns: require_stale.constructGlobs(workspace),
+		patterns: require_seeds.constructGlobs(workspace),
 		cwd: root,
 		runnables,
 		background
 	});
 	const { secrets, generated } = await stageSecrets(ctx, manifest);
 	if (!push) {
-		require_stale.assertNoStaleSecrets({
+		require_seeds.assertNoStaleSecrets({
 			manifest,
 			stage,
 			supplied: secrets?.custom ?? {}
 		});
 		await require_credentialSchemas.assertStageCredentials({
 			root,
-			patterns: require_stale.constructGlobs(workspace),
+			patterns: require_seeds.constructGlobs(workspace),
 			manifest,
 			stage,
 			supplied: secrets?.custom ?? {}
 		});
 	}
-	const layout = mode === "build" ? require_stale.imageLayout(workspace) : void 0;
+	const layout = mode === "build" ? require_seeds.imageLayout(workspace) : void 0;
 	const composed = composeStack({
 		workspace,
 		manifest,
@@ -1647,10 +2127,13 @@ async function validateCompose(ctx, deps, options = {}) {
 		...layout ? { layout } : {},
 		...push ? { buildOnly: true } : {}
 	});
-	require_stale.reportDevServices(ctx, composed.devServices);
+	require_seeds.reportDevServices(ctx, composed.devServices);
 	if (mode === "build") assertRedisClient(workspace, composed);
 	const stack = options.pin ? withPinnedImages(composed, options.pin.file, options.pin.digests) : composed;
 	if (mode === "pull" && !ctx.dryRun) await assertImagesExist(deps.docker, tag, [...stack.apps, ...stack.workers]);
+	if (stack.tls && !push) {
+		for (const file of [stack.tls.certFile, stack.tls.keyFile]) if (!(0, node_fs.existsSync)(file)) throw new require_workspace.ComposeTlsFileMissing(stage, file);
+	}
 	if (stack.redis && !stack.local) ctx.secrets.mask(stack.redis.password);
 	if (stack.logs && (!stack.local || stack.logs.passwordFromSecrets)) {
 		ctx.secrets.mask(stack.logs.password);
@@ -1724,7 +2207,7 @@ async function stageSecrets(ctx, manifest) {
 		secrets: stored,
 		generated: []
 	};
-	const withSeed = require_stale.withGeneratedSecrets(stored ?? require_stale.initStageSecrets(ctx.stage), manifest);
+	const withSeed = require_seeds.withGeneratedSecrets(stored ?? require_seeds.initStageSecrets(ctx.stage), manifest);
 	const withLogs = require_workspace.resolveLogs(ctx.workspace.deploy?.compose?.logs) ? withLogsPassword(withSeed.secrets) : {
 		secrets: withSeed.secrets,
 		generated: []
@@ -1778,6 +2261,13 @@ async function planCompose(ctx, run) {
 	if (run.generated.length > 0) ctx.logger.info(`🔑 "${ctx.stage}" has no ${run.generated.join(", ")} yet; this dry run used values it did not keep.`);
 	run.files = await writeStack(ctx.cwd, run.dir, run.stack);
 	printPlan(ctx, run);
+	if (!run.push && run.stack.infra.includes("postgres")) require_seeds.reportPlannedSeeds((await require_databases.plannedSeeds({
+		root: ctx.workspace.root,
+		manifest: ctx.manifest
+	})).map(({ target, seeds }) => ({
+		folder: target.seeds,
+		seeds
+	})), (line) => ctx.logger.info(line));
 	const planned = (change) => {
 		run.changes.push(change);
 		ctx.emit({
@@ -1819,7 +2309,7 @@ async function planCompose(ctx, run) {
 		});
 	}
 	if (!run.push) planned({
-		key: "service:caddy",
+		key: run.stack.proxy === "caddy" ? "service:caddy" : `service:${EDGE_PROJECT}/${EDGE_SERVICE}`,
 		resourceType: "service",
 		action: "ensure"
 	});
@@ -1836,8 +2326,35 @@ async function provisionCompose(ctx, run, deps) {
 		await ctx.secrets.write(run.secrets);
 		ctx.logger.info(`🔑 Generated for "${ctx.stage}" (${ctx.secrets.store}): ${run.generated.join(", ")}`);
 	}
+	const ports = edgePorts(deps.env);
+	await assertEdgePorts(deps.docker, {
+		project: stack.project,
+		proxy: stack.proxy,
+		ports
+	});
 	run.files = await writeStack(ctx.cwd, run.dir, stack);
 	printPlan(ctx, run);
+	if (stack.proxy === "traefik") {
+		const dir = edgeDir(deps.env);
+		ctx.logger.info(`\n🌐 Starting the shared edge (${EDGE_PROJECT}) from ${dir}…`);
+		run.files.push(...await ensureEdge(deps.docker, {
+			dir,
+			ports,
+			logging: {
+				driver: LOG_ROTATION.driver,
+				options: { ...LOG_ROTATION.options }
+			},
+			...ref.output ? { output: ref.output } : {},
+			...ref.signal ? { signal: ref.signal } : {}
+		}));
+		applied(ctx, run, {
+			key: `service:${EDGE_PROJECT}/${EDGE_SERVICE}`,
+			resourceType: "service",
+			action: "ensure",
+			id: `${EDGE_PROJECT}/${EDGE_SERVICE}`,
+			via: "found"
+		});
+	}
 	if (stack.infra.length > 0) {
 		ctx.logger.info(`\n🗄️  Starting ${stack.infra.join(", ")}…`);
 		await deps.docker.up(ref, stack.infra);
@@ -1862,38 +2379,57 @@ async function prepareBuckets(ctx, run, deps) {
 	if (storage.buckets.length === 0) return;
 	const port = await deps.docker.port(run.ref, "minio", 9e3);
 	const client = deps.buckets(port, storage);
-	const created = [...await require_stale.applyBuckets(client, storage.buckets), ...await require_stale.applyPolicies(client, storage.policies)].filter((entry) => entry.created).length;
+	const created = [...await require_seeds.applyBuckets(client, storage.buckets), ...await require_seeds.applyPolicies(client, storage.policies)].filter((entry) => entry.created).length;
 	ctx.logger.info(`🪣  Buckets: ${storage.buckets.join(", ")}${created ? ` (${created} change(s))` : ""}`);
 }
-/** Create what the plan names in the stack's Postgres, then migrate it. */
+/**
+* Create what the plan names in the stack's Postgres, migrate it, then run
+* its seeds — every one, every time, as each construct's owner.
+*/
 async function prepareDatabases(ctx, run, deps) {
 	const { stack } = run;
 	const workspace = ctx.workspace;
 	const port = await deps.docker.port(run.ref, "postgres", 5432);
-	const statements = require_stale.postgresStatements(stack.plan, workspace.name, stack.credential.seed);
+	const statements = require_seeds.postgresStatements(stack.plan, workspace.name, stack.credential.seed);
 	if (statements.length > 0) {
 		ctx.logger.info("🗄️  Creating databases, roles and grants…");
-		await require_stale.applyPostgres(deps.sql(port, stack.credential.master), statements);
+		await require_seeds.applyPostgres(deps.sql(port, stack.credential.master), statements);
 	}
 	const sources = {};
 	const manifest = await require_discover.discover({
-		patterns: require_stale.constructGlobs(workspace),
+		patterns: require_seeds.constructGlobs(workspace),
 		cwd: workspace.root,
 		sources
 	});
-	const env = require_stale.envFor(stack.plan, {
-		ports: { [require_stale.primaryPortKey("postgres")]: port },
+	const env = require_seeds.envFor(stack.plan, {
+		ports: { [require_seeds.primaryPortKey("postgres")]: port },
 		project: workspace.name,
 		master: stack.credential.master,
 		...stack.credential.seed ? { seed: stack.credential.seed } : {}
 	});
-	const runs = await deps.migrate({
+	const options = {
 		root: workspace.root,
 		manifest,
 		sources,
 		env
+	};
+	const runs = await deps.migrate(options);
+	const seeds = await deps.seed({
+		...options,
+		stage: ctx.stage
+	}).catch((error) => {
+		if (error instanceof require_databases.SeedFailed) throw new require_seeds.DeploySeedsFailed(ctx.stage, error.construct, error.seed, error);
+		throw error;
 	});
-	for (const { target, applied } of runs) if (applied.length > 0) ctx.logger.info(`🗄️  ${target.migrations}: applied ${applied.length}`);
+	require_seeds.reportDatabaseRuns(runs.map(({ target, applied }) => ({
+		construct: target.id,
+		folder: target.migrations,
+		applied
+	})), seeds.map(({ target, seeded }) => ({
+		construct: target.id,
+		folder: target.seeds,
+		seeded
+	})), (line) => ctx.logger.info(line), (event) => ctx.emit(event));
 }
 /**
 * Each app's image: built from this checkout — inside Docker, every one of
@@ -1947,6 +2483,12 @@ async function releaseCompose(ctx, run, deps) {
 	if (run.push) return;
 	ctx.logger.info("\n🚀 Starting the stack…");
 	await deps.docker.up(ref);
+	const edge = edgeDir(deps.env);
+	if (stack.proxy === "traefik" && stack.traefik) {
+		const written = await writeEdgeRoutes(edge, stack.project, stack.traefik, stack.tls);
+		run.files.push(...written);
+		ctx.logger.info(`🌐 Registered ${stack.routes.length} route(s) with ${EDGE_PROJECT}: ${written.at(-1)}`);
+	} else await removeEdgeRoutes(edge, stack.project);
 	if (stack.local) await deps.docker.copyOut(ref, "caddy", "/data/caddy/pki/authorities/local/root.crt", caFile(run)).catch(() => {});
 	await recordImages(ctx, run);
 	for (const app of stack.apps) {
@@ -1984,13 +2526,13 @@ async function releaseCompose(ctx, run, deps) {
 * the tag resolved to.
 */
 async function recordImages(ctx, run) {
-	const journal = await require_stale.DeployJournal.open(ctx.state, ctx.stage, () => require_stale.createEmptyState(ctx.stage, "", ""));
+	const journal = await require_seeds.DeployJournal.open(ctx.state, ctx.stage, () => require_seeds.createEmptyState(ctx.stage, "", ""));
 	for (const app of [...run.stack.apps, ...run.stack.workers]) {
 		const image = run.images[app.app] ?? {
 			ref: app.ref,
 			tag: app.tag
 		};
-		require_stale.recordRelease(journal.state, app.app, image);
+		require_seeds.recordRelease(journal.state, app.app, image);
 	}
 	journal.state.identity = ctx.identity.key;
 	await journal.save();
@@ -2005,10 +2547,14 @@ async function verifyCompose(ctx, run, deps) {
 	const { stack } = run;
 	if (run.push) return;
 	const ca = stack.local ? await (0, node_fs_promises.readFile)(caFile(run), "utf-8").catch(() => void 0) : void 0;
-	ctx.logger.info("\n🩺 Checking each app through Caddy…");
+	ctx.logger.info(`\n🩺 Checking each app through ${stack.proxy === "caddy" ? "Caddy" : "the shared edge"}…`);
+	const edge = stack.local || stack.proxy === "traefik" ? {
+		connectTo: "127.0.0.1",
+		...stack.local ? {} : { connectPort: edgePorts(deps.env).https }
+	} : void 0;
 	const results = await Promise.all(stack.apps.map((app) => checkApp(ctx, app, deps, {
 		ca,
-		local: stack.local
+		edge
 	})));
 	results.push(...await Promise.all(stack.workers.map((worker) => checkContainer(ctx, run, deps, worker.name))));
 	if (stack.logs) results.push(await checkContainer(ctx, run, deps, LOGS_SERVICE));
@@ -2017,7 +2563,7 @@ async function verifyCompose(ctx, run, deps) {
 		url,
 		last
 	}));
-	if (down.length > 0) throw new ComposeAppsUnhealthy(stack.project, down);
+	if (down.length > 0) throw new ComposeAppsUnhealthy(stack.project, down, stack.proxy);
 	if (stack.logs) reportLogs(ctx, stack.logs, stack.local);
 }
 /**
@@ -2096,7 +2642,7 @@ async function checkApp(ctx, app, deps, options) {
 			status = await deps.probe({
 				url,
 				...options.ca ? { ca: options.ca } : {},
-				...options.local ? { connectTo: "127.0.0.1" } : {},
+				...options.edge,
 				timeoutMs: 1e4,
 				signal: ctx.signal
 			});
@@ -2197,19 +2743,34 @@ async function writeStack(root, dir, stack) {
 		files.push(path);
 	};
 	await write((0, node_path.join)(dir, "docker-compose.yml"), composeYaml(stack));
-	await write((0, node_path.join)(dir, "Caddyfile"), stack.caddyfile);
+	if (stack.caddyfile !== void 0) {
+		await write((0, node_path.join)(dir, "Caddyfile"), stack.caddyfile);
+		await (0, node_fs_promises.rm)((0, node_path.join)(dir, "traefik.yml"), { force: true });
+	} else await (0, node_fs_promises.rm)((0, node_path.join)(dir, "Caddyfile"), { force: true });
+	if (stack.traefik !== void 0) await write((0, node_path.join)(dir, "traefik.yml"), stack.traefik);
+	if (stack.proxy === "caddy" && stack.tls) {
+		await (0, node_fs_promises.mkdir)((0, node_path.join)(dir, "tls"), {
+			recursive: true,
+			mode: 448
+		});
+		await write((0, node_path.join)(dir, "tls", "cert.pem"), await (0, node_fs_promises.readFile)(stack.tls.certFile, "utf-8"));
+		await write((0, node_path.join)(dir, "tls", "key.pem"), await (0, node_fs_promises.readFile)(stack.tls.keyFile, "utf-8"), 384);
+	} else await (0, node_fs_promises.rm)((0, node_path.join)(dir, "tls"), {
+		recursive: true,
+		force: true
+	});
 	for (const app of [...stack.apps, ...stack.workers]) if (app.env) await write((0, node_path.join)(dir, `${app.name}.env`), envFile(app.env), 384);
 	if (stack.logs && stack.compose.services["openobserve"]?.env_file) await write((0, node_path.join)(dir, `${LOGS_SERVICE}.env`), envFile(stack.logs.env), 384);
 	if (stack.redis && stack.compose.services["redis"]?.env_file) await write((0, node_path.join)(dir, `${REDIS_SERVICE}.env`), envFile(stack.redis.env), 384);
 	for (const entry of await (0, node_fs_promises.readdir)(dir)) if (entry.endsWith(".credentials")) await (0, node_fs_promises.rm)((0, node_path.join)(dir, entry));
 	for (const [path, content] of Object.entries(stack.dockerfiles)) await write((0, node_path.join)(root, path), content);
-	await require_stale.ensureDockerignore(require_stale.findBuildRoot(root));
+	await require_seeds.ensureDockerignore(require_seeds.findBuildRoot(root));
 	return files;
 }
 function composeYaml(stack) {
 	const stage = ` --stage ${stack.stage}`;
 	return `# Generated by gkm compose from the construct manifest — do not edit.
-# The ${stack.stage} stage's APIs and sites behind one Caddy, and its workers.
+# The ${stack.stage} stage's APIs and sites behind ${stack.proxy === "caddy" ? "one Caddy" : `the shared Traefik edge (${EDGE_PROJECT})`}, and its workers.
 # Each backend and worker reads exactly the keys in its own env file beside
 # this one.
 #
@@ -2305,6 +2866,12 @@ Object.defineProperty(exports, "ComposePushNeedsBuild", {
 		return ComposePushNeedsBuild;
 	}
 });
+Object.defineProperty(exports, "EDGE_PROJECT", {
+	enumerable: true,
+	get: function() {
+		return EDGE_PROJECT;
+	}
+});
 Object.defineProperty(exports, "composeProject", {
 	enumerable: true,
 	get: function() {
@@ -2329,6 +2896,12 @@ Object.defineProperty(exports, "dockerCompose", {
 		return dockerCompose;
 	}
 });
+Object.defineProperty(exports, "edgeDir", {
+	enumerable: true,
+	get: function() {
+		return edgeDir;
+	}
+});
 Object.defineProperty(exports, "parseDigests", {
 	enumerable: true,
 	get: function() {
@@ -2341,6 +2914,12 @@ Object.defineProperty(exports, "pinnedRef", {
 		return pinnedRef;
 	}
 });
+Object.defineProperty(exports, "removeEdgeRoutes", {
+	enumerable: true,
+	get: function() {
+		return removeEdgeRoutes;
+	}
+});
 Object.defineProperty(exports, "stackDir", {
 	enumerable: true,
 	get: function() {
@@ -2354,4 +2933,4 @@ Object.defineProperty(exports, "stackOverrideFile", {
 	}
 });
 
-//# sourceMappingURL=compose-CePlrbUw.cjs.map
+//# sourceMappingURL=compose-CtUP07r3.cjs.map