reeval 0.9.0 → 0.10.0

package/dist/environment-1jE-HhO-.js

@@ -1,657 +0,0 @@
-import { t as parseDuration } from "./duration-JsJrIWXq.js";
-import { n as SECRET_NAME } from "./redact-DJ9JCShu.js";
-import { i as PACKAGE_DIR, n as COMPILED } from "./root-CvdRlRZX.js";
-import picomatch from "picomatch";
-import { readdirSync, realpathSync, statSync } from "node:fs";
-import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
-import { isIP } from "node:net";
-import { fileURLToPath } from "node:url";
-//#region src/environment.ts
-var DefinitionError = class extends Error {
-	name = "DefinitionError";
-};
-const NAME = /^[A-Za-z0-9][A-Za-z0-9._@+-]*$/;
-const VAR = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const SPEC_KEYS = [
-	"sandbox",
-	"workspace",
-	"env",
-	"egress",
-	"files",
-	"rules",
-	"setup",
-	"skills",
-	"mcp"
-];
-/** Image fields that belong on `sandbox: docker({ … })`, not as sibling keys. */
-const SANDBOX_KEYS = [
-	"image",
-	"install",
-	"dockerfile",
-	"from"
-];
-const SPEC_HINTS = {
-	exec: "setup",
-	steps: "setup",
-	run: "setup",
-	vars: "env",
-	secrets: "env",
-	network: "egress",
-	networkPolicy: "egress",
-	skill: "skills",
-	file: "files",
-	agents: "rules",
-	use: "extend",
-	repo: "workspace",
-	git: "workspace",
-	template: "workspace"
-};
-const isSecret = (value) => typeof value === "object" && value !== null && value.kind === "secret";
-const isSecretTemplate = (value) => typeof value === "object" && value !== null && value.kind === "secret-template";
-const isHostFile = (value) => typeof value === "object" && value !== null && value.kind === "file";
-const isEnvironment = (value) => typeof value === "object" && value !== null && value.kind === "environment" && Array.isArray(value.layers);
-const OWN_DIRS = COMPILED ? [join(PACKAGE_DIR, sep)] : ["src", "dist"].map((dir) => join(PACKAGE_DIR, dir, sep));
-/** The directory of the file that called into reeval, from the stack; relative paths resolve here. */
-function callerDir() {
-	const limit = Error.stackTraceLimit;
-	Error.stackTraceLimit = 30;
-	const stack = (/* @__PURE__ */ new Error()).stack ?? "";
-	Error.stackTraceLimit = limit;
-	for (const line of stack.split("\n").slice(1)) {
-		const match = /(?:\(|at )((?:file:\/\/)?\/[^()]*?|[A-Za-z]:[\\/][^()]*?):\d+:\d+\)?\s*$/.exec(line);
-		if (!match?.[1]) continue;
-		const file = normalize(match[1].startsWith("file://") ? fileURLToPath(match[1]) : match[1]);
-		if (OWN_DIRS.some((d) => file.startsWith(d)) || file.includes(`${sep}node_modules${sep}`)) continue;
-		return dirname(file);
-	}
-}
-const toPath = (value, base) => {
-	const path = value instanceof URL ? fileURLToPath(value) : value;
-	return isAbsolute(path) ? path : resolve(base, path);
-};
-/**
-* A tarball or folder spec (`./x.tgz`, `../pkg`, `/abs`, `file:…`) as an absolute path, resolved
-* like `file()`; npm resolves relative ones against its working directory, reeval's cache.
-*/
-const localNpmSpec = (spec, base) => {
-	const path = spec.startsWith("file:") ? spec.slice(5) : spec;
-	return /^\.{1,2}(?:\/|$)/.test(path) || isAbsolute(path) ? toPath(path, base) : spec;
-};
-/** A host name, or `*.` and a domain for its subdomains. */
-const HOST = /^(?:\*\.)?[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*$/i;
-const SUBSTITUTE_IN = [
-	"header",
-	"query",
-	"body"
-];
-/** Why `host` isn't a host name or `*.` pattern, or undefined when it is one. */
-function badHost(host) {
-	if (typeof host === "string" && HOST.test(host)) {
-		const name = host.replace(/^\*\./, "");
-		if (/(?:^|\.)\d+$/.test(name) && (name !== host || isIP(name) !== 4)) return `'${host}' isn't a host name or an IPv4 address, and a *. pattern never matches an address.`;
-		if (name !== host && !name.includes(".")) return `'${host}' would allow every host under .${name}; name the domain, e.g. '*.example.${name}'.`;
-		return;
-	}
-	if (typeof host === "string" && /^[a-z]+:\/\//i.test(host)) return `hosts are host names, not URLs: use '${new URL(host).hostname}' (got '${host}')`;
-	if (typeof host === "string" && /^[^:/]+:\d+$/.test(host)) return `hosts are host names without a port: use '${host.split(":")[0]}' (got '${host}')`;
-	return `${JSON.stringify(host)} isn't a host. Use a name like 'api.example.com', or '*.example.com' for its subdomains.`;
-}
-/** Throws unless `value` is `'allow-all'`, `'deny-all'` or `{ allow: [hosts] }`. */
-function checkEgress(value, where, Err = DefinitionError) {
-	if (value === "allow-all" || value === "deny-all") return;
-	const shape = `egress is 'allow-all' (the default), 'deny-all', or { allow: ['api.example.com', '*.example.org'] }`;
-	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		const list = Array.isArray(value) ? ` For a list of hosts, use { allow: ${JSON.stringify(value)} }.` : "";
-		throw new Err(`${shape} (got ${JSON.stringify(value)}) in ${where}.${list}`);
-	}
-	for (const key of Object.keys(value)) {
-		if (key === "allow") continue;
-		throw new Err(`Unknown egress key "${key}" in ${where}.${key === "deny" ? " A policy lists what's allowed; everything else is refused." : key === "hosts" || key === "allowedHosts" ? " Did you mean \"allow\"?" : ""}`);
-	}
-	const allow = value.allow;
-	if (!Array.isArray(allow)) throw new Err(`${shape} (got ${JSON.stringify(value)}) in ${where}`);
-	for (const host of allow) {
-		const bad = badHost(host);
-		if (bad) throw new Err(`egress.allow in ${where}: ${bad}`);
-	}
-}
-const SECRET_HOSTS = Object.freeze({
-	gemini: Object.freeze(["generativelanguage.googleapis.com"]),
-	openai: Object.freeze(["api.openai.com"]),
-	anthropic: Object.freeze(["api.anthropic.com"]),
-	github: Object.freeze(["api.github.com", "uploads.github.com"])
-});
-function secretOptions(options, what) {
-	const to = options.to ?? "agent";
-	if (to !== "agent" && to !== "checks") throw new DefinitionError(`${what}: to must be 'agent' or 'checks'`);
-	const { hosts } = options;
-	if (hosts !== void 0) {
-		if (!Array.isArray(hosts) || hosts.length === 0) throw new DefinitionError(`${what}: hosts must list the hosts the secret is sent to, e.g. hosts: ['api.example.com'] or secret.hosts.gemini (got ${JSON.stringify(hosts)})`);
-		for (const host of hosts) {
-			const bad = badHost(host);
-			if (bad) throw new DefinitionError(`${what}: ${bad}`);
-		}
-	}
-	if (options.in !== void 0) {
-		if (hosts === void 0) throw new DefinitionError(`${what}: in only applies to a brokered secret; add hosts, e.g. { hosts: ['api.example.com'], in: ${JSON.stringify(options.in)} }`);
-		if ((Array.isArray(options.in) ? options.in.filter((i) => !SUBSTITUTE_IN.includes(i)) : [options.in]).length || options.in.length === 0) throw new DefinitionError(`${what}: in lists where the gateway substitutes: 'header', 'query' and/or 'body' (got ${JSON.stringify(options.in)})`);
-	}
-	return {
-		...options.optional ? { optional: true } : {},
-		...to === "checks" ? { to } : {},
-		...hosts ? { hosts: [...hosts] } : {},
-		...options.in ? { in: [...new Set(options.in)] } : {}
-	};
-}
-/** Where an MCP server's header secrets are brokered to by default: its own host, over HTTPS. */
-function mcpHosts(url) {
-	try {
-		const u = new URL(url);
-		return u.protocol === "https:" ? [u.hostname] : void 0;
-	} catch {
-		return;
-	}
-}
-/**
-* Every secret among `env` and the layers' env and MCP servers, layered as the attempt resolves
-* them: a later layer's variable or MCP server replaces an earlier one of the same name.
-*/
-function plannedSecrets(env, layers) {
-	const vars = { ...env };
-	const servers = /* @__PURE__ */ new Map();
-	for (const { spec } of layers) {
-		Object.assign(vars, spec.env);
-		for (const [name, server] of Object.entries(spec.mcp ?? {})) servers.set(name, server);
-	}
-	const out = /* @__PURE__ */ new Map();
-	const add = (label, from, hosts, checksOnly = false, optional = false) => out.set(`${label}\0${from}`, {
-		label,
-		from,
-		...hosts ? { hosts } : {},
-		...checksOnly ? { checksOnly } : {},
-		...optional ? { optional } : {}
-	});
-	const fromVars = (values, prefix) => {
-		for (const [name, value] of Object.entries(values)) if (isSecret(value)) add(`${prefix}${name}`, value.from ?? name, value.hosts, value.to === "checks", value.optional === true);
-	};
-	fromVars(vars, "");
-	for (const [server, s] of servers) {
-		if (s.transport === "stdio") {
-			fromVars(s.env, `mcp.${server}.env.`);
-			continue;
-		}
-		const own = mcpHosts(s.url);
-		for (const [header, value] of Object.entries(s.headers)) {
-			const label = `mcp.${server}.headers.${header}`;
-			if (isSecret(value)) add(label, value.from ?? header, value.hosts ?? own);
-			if (isSecretTemplate(value)) for (const [, name] of value.template.matchAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g)) add(label, name, own);
-		}
-	}
-	return [...out.values()];
-}
-/** The secrets the sandbox gets as real values: no `hosts`, and none implied by an MCP URL. */
-const unbrokeredSecrets = (env, layers) => plannedSecrets(env, layers).flatMap(({ hosts, ...s }) => hosts ? [] : [s]);
-function secretHelper() {
-	const secret = ((options = {}) => ({
-		kind: "secret",
-		...secretOptions(options, "secret()")
-	}));
-	secret.fromEnv = (host, options = {}) => {
-		if (typeof host !== "string" || !VAR.test(host)) throw new DefinitionError(`secret.fromEnv(${JSON.stringify(host)}) needs a host variable name`);
-		return {
-			kind: "secret",
-			from: host,
-			...secretOptions(options, `secret.fromEnv("${host}")`)
-		};
-	};
-	secret.template = (template) => ({
-		kind: "secret-template",
-		template
-	});
-	secret.hosts = SECRET_HOSTS;
-	return secret;
-}
-const MOVING = /^(?:main|master|HEAD|trunk|develop|dev|latest)$/;
-/** A git ref that isn't a commit SHA or a version-like tag. */
-const isMovingRef = (ref) => ref === void 0 || MOVING.test(ref) || !/^(?:[0-9a-f]{7,40}|v?\d+(?:\.\d+)*(?:[-+].*)?)$/.test(ref);
-/** `github:owner/repo` and GitHub `/tree/<ref>/<path>` URLs, as a clone URL plus ref and path. */
-function parseGitRepo(repo) {
-	const short = /^github:([\w.-]+\/[\w.-]+?)(?:\.git)?$/.exec(repo);
-	if (short) return { url: `https://github.com/${short[1]}.git` };
-	const tree = /^https:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/tree\/([^/]+)(?:\/(.+))?$/.exec(repo);
-	if (tree) return {
-		url: `https://github.com/${tree[1]}.git`,
-		ref: tree[2],
-		path: tree[3]
-	};
-	return { url: repo };
-}
-/** `repo#ref:path`, as the plan and the record name a git workspace. */
-const workspaceLabel = (w) => `${w.repo}${w.ref ? `#${w.ref}` : ""}${w.path ? `:${w.path}` : ""}`;
-/** The workspace an attempt starts as: the last layer that sets one. */
-const workspaceOf = (layers) => layers.findLast((l) => l.spec.workspace)?.spec.workspace;
-/** The paths the layers' `files` write, sorted. */
-const filesOf = (layers) => [...new Set(layers.flatMap((l) => Object.keys(l.spec.files ?? {})))].sort();
-/** A URL with its password (or an https username, which is where tokens go) masked. */
-function credentialsIn(repo) {
-	if (!URL.canParse(repo)) return void 0;
-	const u = new URL(repo);
-	if (!u.password && !(u.username && /^https?:$/.test(u.protocol))) return void 0;
-	u.username = u.username && "***";
-	u.password = u.password && "***";
-	return u.href;
-}
-const GIT_OPTIONS = [
-	"ref",
-	"path",
-	"init",
-	"token"
-];
-const isLocalPath = (repo) => /^\.{1,2}(?:\/|$)/.test(repo) || isAbsolute(repo);
-function gitHelper(base) {
-	return (repo, options = {}) => {
-		const written = repo instanceof URL ? repo.href : repo;
-		if (typeof written !== "string" || !written.trim()) throw new DefinitionError(`git() needs a repository: a URL, github:owner/repo or a local path (got ${JSON.stringify(repo)})`);
-		const what = `git(${JSON.stringify(written)})`;
-		const masked = credentialsIn(written);
-		if (masked) throw new DefinitionError(`git(${JSON.stringify(masked)}): the URL has a password or token in it. reeval fetches the repository on the host with your own git credentials (a credential helper, gh auth setup-git or an SSH key), and the sandbox never gets them; remove it from the URL.`);
-		if (typeof options !== "object" || options === null || Array.isArray(options)) throw new DefinitionError(`${what}: options are { ref?, path? }`);
-		const extra = Object.keys(options).filter((k) => !GIT_OPTIONS.includes(k));
-		if (extra.length) {
-			const hint = extra.includes("branch") || extra.includes("tag") ? " Use ref for a branch, tag or commit." : "";
-			throw new DefinitionError(`${what}: unknown option "${extra.join("\", \"")}"; it takes ${GIT_OPTIONS.slice(0, -1).join(", ")} and ${GIT_OPTIONS.at(-1)}.${hint}`);
-		}
-		const local = repo instanceof URL ? repo.protocol === "file:" : isLocalPath(written);
-		const parsed = local ? { url: toPath(repo, base) } : parseGitRepo(written);
-		const ref = options.ref ?? parsed.ref;
-		if (ref !== void 0 && (typeof ref !== "string" || !ref.trim() || ref.startsWith("-"))) throw new DefinitionError(`${what}: ref is a branch, tag or commit SHA (got ${JSON.stringify(ref)})`);
-		const path = options.path ?? parsed.path;
-		if (path !== void 0) {
-			const clean = typeof path === "string" ? path.replace(/\/+$/, "") : path;
-			if (typeof clean !== "string" || !clean || clean.includes("\\") || clean.startsWith("/") || clean.split("/").some((p) => p === ".." || p === "." || p === "")) throw new DefinitionError(`${what}: path is a directory in the repository, relative, with forward slashes and no . or .. (got ${JSON.stringify(path)})`);
-		}
-		const cleanPath = path?.replace(/\/+$/, "");
-		const { init, token } = options;
-		if (init !== void 0 && typeof init !== "boolean") throw new DefinitionError(`${what}: init is true or false (got ${JSON.stringify(init)})`);
-		if (token !== void 0) {
-			if (typeof token !== "string" || !VAR.test(token) || /^(?:gh[opsur]_|github_pat_)/.test(token)) throw new DefinitionError(`${what}: token names the host variable that holds the token, e.g. token: 'GITHUB_TOKEN'. Don't put the token itself in the eval.`);
-			if (local || !/^https?:\/\//.test(parsed.url)) throw new DefinitionError(`${what}: token only works with an https:// URL; for SSH or a local repository, git uses this machine's own credentials`);
-		}
-		return {
-			kind: "git",
-			repo: "ref" in parsed || "path" in parsed ? parsed.url.replace(/\.git$/, "") : written,
-			url: parsed.url,
-			...ref ? { ref } : {},
-			...cleanPath ? { path: cleanPath } : {},
-			...init ? { init } : {},
-			...token ? { token } : {}
-		};
-	};
-}
-/**
-* What a skill directory leaves out of the sandbox unless `exclude` says otherwise: eval material
-* (skill-creator keeps `evals/` in the skill), run history and reeval eval files. `.git` is always left out.
-*/
-const DEFAULT_SKILL_EXCLUDE = [
-	"/evals/",
-	".history/",
-	"*.eval.ts"
-];
-function skillHelper(base) {
-	const placement = (p) => {
-		if (p === void 0 || p === "harness" || p === "workspace") return p ?? "harness";
-		throw new DefinitionError(`skill placement must be 'harness' or 'workspace' (got ${p})`);
-	};
-	const exclude = (e) => {
-		if (e === void 0) return {};
-		if (!Array.isArray(e) || e.some((p) => typeof p !== "string" || !p.replace(/\//g, ""))) throw new DefinitionError(`skill exclude must be an array of paths or globs, e.g. ['/evals/', '*.eval.ts'] (got ${JSON.stringify(e)})`);
-		return { exclude: [...e] };
-	};
-	return {
-		local: (path, o = {}) => ({
-			kind: "skill",
-			source: "local",
-			path: toPath(path, base),
-			...o.only ? { only: [...o.only] } : {},
-			...exclude(o.exclude),
-			placement: placement(o.placement)
-		}),
-		git: (repo, o = {}) => {
-			if (typeof repo !== "string" || !repo) throw new DefinitionError("skill.git() needs a repository URL");
-			const parsed = parseGitRepo(repo);
-			const ref = o.ref ?? parsed.ref;
-			const path = o.path ?? parsed.path;
-			return {
-				kind: "skill",
-				source: "git",
-				repo,
-				...ref ? { ref } : {},
-				...path ? { path } : {},
-				...o.only ? { only: [...o.only] } : {},
-				...exclude(o.exclude),
-				placement: placement(o.placement)
-			};
-		},
-		registry: (id, o = {}) => {
-			if (!/^[\w.-]+\/[\w.-]+@[a-z0-9-]+$/.test(id)) throw new DefinitionError(`skill.registry("${id}") needs an id like owner/repo@skill`);
-			return {
-				kind: "skill",
-				source: "registry",
-				id,
-				...o.version ? { version: o.version } : {},
-				placement: placement(o.placement)
-			};
-		},
-		npm: (spec, o = {}) => ({
-			kind: "skill",
-			source: "npm",
-			spec: localNpmSpec(spec, base),
-			path: o.path ?? "skills",
-			...o.only ? { only: [...o.only] } : {},
-			...exclude(o.exclude),
-			placement: placement(o.placement)
-		}),
-		inline: (skill, o = {}) => ({
-			kind: "skill",
-			source: "inline",
-			name: skill.name,
-			description: skill.description,
-			content: skill.content,
-			files: { ...skill.files },
-			placement: placement(o.placement)
-		})
-	};
-}
-/**
-* What `directory()` leaves out unless `defaultIgnores: false`: dependency, build-output, cache
-* and editor directories, in its `glob` syntax. `build/` and `target/` are anchored to the top of
-* the directory, where Flutter, Dart, Gradle and Cargo put their output, since a nested one can be
-* source. `vendor/` isn't here: a committed Go or PHP vendor directory is what an offline build needs.
-*/
-const DEFAULT_DIRECTORY_IGNORES = Object.freeze([
-	"node_modules/",
-	".DS_Store",
-	"dist/",
-	".next/",
-	".turbo/",
-	"coverage/",
-	".cache/",
-	"__pycache__/",
-	".venv/",
-	"venv/",
-	".pytest_cache/",
-	".mypy_cache/",
-	"*.pyc",
-	".dart_tool/",
-	"/build/",
-	"/target/",
-	".gradle/",
-	".idea/",
-	".vscode/"
-]);
-/**
-* A gitignore-style pattern as a test of a file's path, matched by picomatch: a pattern without an
-* inner `/` matches a name at any depth, a leading `/` anchors, a trailing `/` names a directory,
-* and a pattern also matches every file in a directory it names.
-*/
-function globTest(pattern) {
-	const dirOnly = pattern.endsWith("/");
-	const body = pattern.replace(/\/+$/, "").replaceAll("[!", "[^");
-	const glob = body.includes("/") ? body.replace(/^\/+/, "") : `**/${body}`;
-	const self = picomatch(glob, { dot: true });
-	const inside = picomatch(`${glob}/**/*`, { dot: true });
-	return (path, isDir = false) => inside(path) || (isDir || !dirOnly) && self(path);
-}
-/**
-* `glob` as a test of a directory-relative file path: the last pattern that matches decides, a
-* `!` one excluding; a file no pattern matches is in unless some pattern includes.
-*/
-function globFilter(patterns) {
-	const rules = patterns.map((p) => ({
-		include: !p.startsWith("!"),
-		test: globTest(p.replace(/^!/, ""))
-	}));
-	const start = !rules.some((r) => r.include);
-	return (path, isDir) => rules.reduce((keep, r) => r.test(path, isDir) ? r.include : keep, start);
-}
-const DIRECTORY_OPTIONS = [
-	"into",
-	"glob",
-	"defaultIgnores"
-];
-function directoryHelper(base) {
-	return (path, options = {}) => {
-		const written = path instanceof URL ? path.href : path;
-		const what = `directory(${JSON.stringify(written)})`;
-		if (typeof written !== "string" || !written) throw new DefinitionError(`directory() needs a path to a directory, relative to this file (got ${JSON.stringify(path)})`);
-		if (typeof options !== "object" || options === null || Array.isArray(options)) throw new DefinitionError(`${what}: options are { into?, glob?, defaultIgnores? }`);
-		const extra = Object.keys(options).filter((k) => !DIRECTORY_OPTIONS.includes(k));
-		if (extra.length) {
-			const hint = extra.includes("ignore") || extra.includes("exclude") ? " Exclude with a '!' pattern in glob, e.g. glob: ['!dist/']." : "";
-			throw new DefinitionError(`${what}: unknown option "${extra.join("\", \"")}"; it takes into, glob and defaultIgnores.${hint}`);
-		}
-		const { into, glob = [], defaultIgnores = true } = options;
-		if (into !== void 0 && (typeof into !== "string" || into.includes("\\") || isAbsolute(into) || into.split("/").some((p) => p === ".."))) throw new DefinitionError(`${what}: into is a directory relative to the workspace (or ~/…), with forward slashes and no .. (got ${JSON.stringify(into)})`);
-		if (!Array.isArray(glob) || glob.some((p) => typeof p !== "string" || !p.replace(/^!/, "").replace(/\//g, ""))) throw new DefinitionError(`${what}: glob is a list of patterns, e.g. ['src/**', 'package.json', '!**/*.test.ts'] (got ${JSON.stringify(glob)})`);
-		if (typeof defaultIgnores !== "boolean") throw new DefinitionError(`${what}: defaultIgnores is true or false (got ${JSON.stringify(defaultIgnores)})`);
-		const root = toPath(path, base);
-		const stat = statSync(root, { throwIfNoEntry: false });
-		if (!stat) throw new DefinitionError(`${what}: ${root} doesn't exist`);
-		if (!stat.isDirectory()) throw new DefinitionError(`${what}: ${root} is a file, not a directory. Use file(${JSON.stringify(written)}) for one file.`);
-		const skip = defaultIgnores ? globFilter(DEFAULT_DIRECTORY_IGNORES) : () => false;
-		const keep = globFilter(glob);
-		const prefix = into?.replace(/\/+$/, "").replace(/^\.\/?/, "");
-		const files = {};
-		const walk = (dir, rel, seen) => {
-			for (const name of readdirSync(dir).sort()) {
-				if (name === ".git") continue;
-				const full = join(dir, name);
-				const relPath = rel ? `${rel}/${name}` : name;
-				const target = statSync(full, { throwIfNoEntry: false });
-				if (!target) throw new DefinitionError(`${what}: ${relPath} is a symlink to something that doesn't exist. Remove it, or leave it out with glob: ['!${relPath}'].`);
-				if (target.isDirectory()) {
-					if (skip(relPath, true)) continue;
-					const real = realpathSync(full);
-					if (seen.includes(real)) throw new DefinitionError(`${what}: ${relPath} is a symlink to a directory that contains it. Leave it out with glob: ['!${relPath}/'].`);
-					walk(full, relPath, [...seen, real]);
-				} else if (target.isFile() && !skip(relPath) && keep(relPath)) files[prefix ? `${prefix}/${relPath}` : relPath] = {
-					kind: "file",
-					path: full
-				};
-			}
-		};
-		walk(root, "", [realpathSync(root)]);
-		if (Object.keys(files).length === 0) throw new DefinitionError(`${what}: no files in ${root}${glob.length || defaultIgnores ? ` match (glob ${JSON.stringify(glob)}${defaultIgnores ? ", after DEFAULT_DIRECTORY_IGNORES" : ""})` : ""}. Empty directories aren't seeded; create one with a setup step.`);
-		return files;
-	};
-}
-const mcpHelper = {
-	stdio: (command, args = [], o = {}) => {
-		if (typeof command !== "string" || !command) throw new DefinitionError("mcp.stdio() needs a command");
-		return {
-			kind: "mcp",
-			transport: "stdio",
-			command,
-			args: [...args],
-			env: { ...o.env }
-		};
-	},
-	http: (url, o = {}) => ({
-		kind: "mcp",
-		transport: "http",
-		url,
-		headers: { ...o.headers }
-	}),
-	sse: (url, o = {}) => ({
-		kind: "mcp",
-		transport: "sse",
-		url,
-		headers: { ...o.headers }
-	})
-};
-/** The helpers a callback gets, with relative paths resolving against `base`. */
-function helpersFor(base) {
-	return {
-		secret: secretHelper(),
-		skill: skillHelper(base),
-		mcp: mcpHelper,
-		file: (path) => ({
-			kind: "file",
-			path: toPath(path, base)
-		}),
-		directory: directoryHelper(base),
-		git: gitHelper(base)
-	};
-}
-/** Throws on env variables that aren't strings or secrets, or look like literal secrets. */
-function checkEnv(env, where, Err = DefinitionError) {
-	if (typeof env !== "object" || env === null || Array.isArray(env)) throw new Err(`env must be an object of variables in ${where}`);
-	for (const [name, value] of Object.entries(env)) {
-		if (!VAR.test(name)) throw new Err(`env.${name} in ${where} isn't a valid variable name`);
-		if (isSecret(value)) continue;
-		if (typeof value !== "string") throw new Err(`env.${name} in ${where} must be a string or secret.fromEnv()`);
-		if (SECRET_NAME.test(name)) throw new Err(`env.${name} in ${where} is a literal string. Pass secrets with secret.fromEnv() so they're redacted and never recorded.`);
-	}
-}
-const stepCommand = (step) => typeof step === "string" ? step : step.run;
-function checkSpec(spec, where) {
-	if (typeof spec !== "object" || spec === null || Array.isArray(spec)) throw new DefinitionError(`${where} must be an object or a callback that returns one`);
-	for (const key of Object.keys(spec)) {
-		if (SPEC_KEYS.includes(key)) continue;
-		if (SANDBOX_KEYS.includes(key)) {
-			const value = spec[key];
-			throw new DefinitionError(`"${key}" isn't an environment field (${where}). Put the image on the sandbox: sandbox: docker({ ${key === "image" ? typeof value === "string" ? "from" : "install" : key}: … }).`);
-		}
-		throw new DefinitionError(`Unknown field "${key}" in ${where}.${SPEC_HINTS[key] ? ` Did you mean "${SPEC_HINTS[key]}"?` : ""}`);
-	}
-	const s = spec;
-	if (s.sandbox !== void 0) checkSandbox(s.sandbox, where);
-	if (s.workspace !== void 0 && s.workspace?.kind !== "git") throw new DefinitionError(`workspace in ${where} must come from the git helper, e.g. workspace: git('https://github.com/acme/app', { ref: 'v1.0.0' }) (got ${JSON.stringify(s.workspace)})`);
-	if (s.env !== void 0) checkEnv(s.env, where);
-	if (s.egress !== void 0) checkEgress(s.egress, where);
-	const list = (key) => {
-		const value = s[key];
-		if (value !== void 0 && !Array.isArray(value)) throw new DefinitionError(`${key} in ${where} must be a list`);
-		return value ?? [];
-	};
-	for (const step of list("setup")) {
-		const shape = `Steps in ${where} are strings or { run, timeout?, cwd? } objects`;
-		const run = typeof step === "string" ? step : step?.run;
-		if (typeof run !== "string" || !run.trim()) throw new DefinitionError(shape);
-		if (typeof step === "string") continue;
-		const extra = Object.keys(step).filter((k) => ![
-			"run",
-			"timeout",
-			"cwd"
-		].includes(k));
-		if (extra.length) throw new DefinitionError(`${shape} (got "${extra.join("\", \"")}")`);
-		const { cwd, timeout } = step;
-		if (timeout !== void 0) try {
-			parseDuration(timeout);
-		} catch (error) {
-			throw new DefinitionError(`setup step "${run}" in ${where}: ${error.message}`);
-		}
-		if (cwd !== void 0 && (typeof cwd !== "string" || !cwd.trim())) throw new DefinitionError(`setup step "${run}" in ${where}: cwd must be a directory path, relative to the workspace or absolute (got ${JSON.stringify(cwd)})`);
-	}
-	for (const skill of list("skills")) if (skill?.kind !== "skill") throw new DefinitionError(`skills in ${where} must come from the skill helper, e.g. skills: [skill.local('./skills')] (got ${JSON.stringify(skill)})`);
-	for (const [name, server] of Object.entries(s.mcp ?? {})) if (server?.kind !== "mcp") throw new DefinitionError(`mcp.${name} in ${where} must come from the mcp helper, e.g. mcp.stdio('npx', ['-y', 'server'])`);
-	for (const [path, value] of Object.entries(s.files ?? {})) {
-		const key = `files[${JSON.stringify(path)}] in ${where}`;
-		if (path.includes("\\")) throw new DefinitionError(`${key}: use forward slashes (${path.replaceAll("\\", "/")})`);
-		const rest = path.startsWith("~/") ? path.slice(2) : path;
-		if (!rest || isAbsolute(rest) || rest.split("/").includes("..")) throw new DefinitionError(`${key}: paths are relative to the workspace, or start with ~/ for the home directory, and never use ..`);
-		if (typeof value !== "string" && !isHostFile(value)) throw new DefinitionError(`${key} must be a string or file(path)`);
-	}
-	if (s.rules !== void 0 && typeof s.rules !== "string" && !isHostFile(s.rules)) throw new DefinitionError(`rules in ${where} must be markdown or file(path)`);
-	return structuredClone(s);
-}
-function buildSpec(input, where, base) {
-	const spec = typeof input === "function" ? input(helpersFor(base)) : input;
-	if (spec instanceof Promise || typeof spec?.then === "function") throw new DefinitionError(`${where} returned a Promise. The callback runs once at definition time and must return the environment synchronously; fetch remote content in a setup step instead.`);
-	return checkSpec(spec, where);
-}
-function makeEnvironment(name, layers) {
-	const env = {
-		kind: "environment",
-		name,
-		layers: Object.freeze(layers)
-	};
-	const extend = (child, input) => {
-		checkName(child, `${name}.extend`);
-		const where = `${name}.extend("${child}")`;
-		const base = callerDir() ?? process.cwd();
-		return makeEnvironment(child, [...layers, {
-			name: child,
-			spec: buildSpec(input, where, base)
-		}]);
-	};
-	Object.defineProperty(env, "extendEnvironment", {
-		enumerable: false,
-		value: extend
-	});
-	Object.defineProperty(env, "extend", {
-		enumerable: false,
-		value: extend
-	});
-	return Object.freeze(env);
-}
-function checkName(name, what) {
-	if (typeof name !== "string" || !NAME.test(name)) throw new DefinitionError(`${what} needs a name of letters, digits, ".", "_", "@", "+" or "-" (got ${JSON.stringify(name)})`);
-}
-/**
-* What an eval runs in: the sandbox, skills, MCP servers, files, rules, variables, secrets and
-* setup steps. Pass a spec, or a callback that destructures the typed helpers it needs:
-*
-*     defineEnvironment('genkit', ({ secret, skill }) => ({
-*       sandbox: docker({ from: 'node:24-bookworm' }),
-*       env: { GOOGLE_GENAI_API_KEY: secret.fromEnv('GOOGLE_GENERATIVE_AI_API_KEY') },
-*       skills: [skill.local('../skills/genkit')],
-*     }))
-*
-* The callback runs once, synchronously. Relative paths resolve against the calling file.
-* `extend` / `extendEnvironment` replace `sandbox` entirely when the child sets one; when
-* the child omits it, the parent's sandbox is kept. A bare `defineEnvironment('plain', {})`
-* that is not an extend uses the cascaded option sandbox, else implicit Docker.
-*/
-function defineEnvironment(name, input) {
-	checkName(name, "defineEnvironment");
-	const base = callerDir() ?? process.cwd();
-	return makeEnvironment(name, [{
-		name,
-		spec: buildSpec(input, `defineEnvironment("${name}")`, base)
-	}]);
-}
-/** The control of a compare without a `baseline` when nothing in the cascade sets an environment. */
-const EMPTY_BASELINE = "baseline";
-/**
-* An environment with no layers. As a compare's empty control it uses the first
-* variant's sandbox when that variant sets one, else the cascaded option sandbox,
-* else the implicit default Docker sandbox.
-*/
-const emptyEnvironment = (name) => makeEnvironment(name, []);
-/** The last layer that sets `sandbox`, else `fallback` (the cascaded option sandbox). */
-const sandboxOf = (layers, fallback) => layers.findLast((l) => l.spec.sandbox)?.spec.sandbox ?? fallback;
-/** The sandbox an environment names, else `fallback`. */
-const environmentSandbox = (env, fallback) => sandboxOf(env?.layers ?? [], fallback);
-function checkSandbox(value, where) {
-	const kind = value?.kind;
-	if (kind !== "docker" && kind !== "fake") throw new DefinitionError(`sandbox in ${where} must come from docker() or fakeSandbox() (got ${JSON.stringify(value)})`);
-	const max = value.maxConcurrent;
-	if (max !== void 0 && !(Number.isInteger(max) && max >= 1)) throw new DefinitionError(`sandbox.maxConcurrent in ${where} must be a whole number of at least 1 (got ${String(max)})`);
-}
-function applied(env) {
-	if (!env) return {
-		name: "-",
-		parent: null,
-		layers: []
-	};
-	return {
-		name: env.name,
-		parent: env.layers.at(-2)?.name ?? null,
-		layers: [...env.layers]
-	};
-}
-//#endregion
-export { stepCommand as C, workspaceOf as E, sandboxOf as S, workspaceLabel as T, isSecret as _, callerDir as a, parseGitRepo as b, defineEnvironment as c, filesOf as d, globFilter as f, isMovingRef as g, isHostFile as h, applied as i, emptyEnvironment as l, isEnvironment as m, DEFAULT_SKILL_EXCLUDE as n, checkEgress as o, helpersFor as p, EMPTY_BASELINE as r, checkEnv as s, DEFAULT_DIRECTORY_IGNORES as t, environmentSandbox as u, isSecretTemplate as v, unbrokeredSecrets as w, plannedSecrets as x, mcpHosts as y };
-
-//# sourceMappingURL=environment-1jE-HhO-.js.map