portcall 0.0.0-stage → 0.2.0

package/dist/portcall.mjs

@@ -0,0 +1,2886 @@
+#!/usr/bin/env node
+import { basename, dirname, join, resolve, sep } from "node:path";
+import process from "node:process";
+import { parseArgs, promisify } from "node:util";
+import { execFile, spawn } from "node:child_process";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { Buffer } from "node:buffer";
+import { homedir } from "node:os";
+import { readlink } from "node:fs/promises";
+import { connect } from "node:net";
+import { createInterface } from "node:readline";
+// package.json
+var version$1 = "0.2.0";
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/core.js
+var _a$1;
+const _zodDesc = {
+	value: void 0,
+	enumerable: false
+};
+let _E = "captureStackTrace" in Error ? Error : null;
+function newError(Definition) {
+	const E = _E;
+	if (E) {
+		const saved = E.stackTraceLimit;
+		if (typeof saved === "number") {
+			try {
+				E.stackTraceLimit = 0;
+			} catch {
+				_E = null;
+				return new Definition();
+			}
+			try {
+				return new Definition();
+			} finally {
+				E.stackTraceLimit = saved;
+			}
+		}
+	}
+	return new Definition();
+}
+/* @__NO_SIDE_EFFECTS__ */
+function $constructor(name, initializer, proto, params) {
+	const zodProto = {};
+	function Internals(def) {
+		this.def = def;
+		this.constr = _;
+		this.traits = /* @__PURE__ */ new Set();
+	}
+	Internals.prototype = zodProto;
+	const protoMembers = proto;
+	const initialized = protoMembers && /* @__PURE__ */ new WeakSet();
+	function init(inst, def) {
+		if (!inst._zod) {
+			_zodDesc.value = new Internals(def);
+			try {
+				Object.defineProperty(inst, "_zod", _zodDesc);
+			} finally {
+				_zodDesc.value = void 0;
+			}
+		} else if (inst._zod.traits.has(name)) return;
+		inst._zod.traits.add(name);
+		initializer(inst, def);
+		if (initialized) {
+			const own = Object.getPrototypeOf(inst);
+			const ctorProto = inst._zod.constr.prototype;
+			let up = own;
+			while (up && up !== ctorProto) up = Object.getPrototypeOf(up);
+			const target = up ?? own;
+			if (!initialized.has(target)) {
+				initialized.add(target);
+				members(target, protoMembers);
+			}
+		}
+		const proto = _.prototype;
+		for (const k in proto) {
+			if (!Object.prototype.hasOwnProperty.call(proto, k)) continue;
+			if (!(k in inst)) inst[k] = proto[k].bind(inst);
+		}
+	}
+	const Parent = params?.Parent ?? Object;
+	class Definition extends Parent {}
+	Object.defineProperty(Definition, "name", { value: name });
+	function _(def) {
+		const inst = params?.Parent ? newError(Definition) : this;
+		init(inst, def);
+		const deferred = inst._zod.deferred;
+		if (deferred) {
+			for (const fn of deferred) fn();
+			inst._zod.deferred = void 0;
+		}
+		const pp = globalThis.__zod_globalConfig?.postProcessor;
+		if (pp) pp(inst);
+		return inst;
+	}
+	Object.defineProperty(_, "init", { value: init });
+	Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {
+		if (params?.Parent && inst instanceof params.Parent) return true;
+		return inst?._zod?.traits?.has(name);
+	} });
+	Object.defineProperty(_, "name", { value: name });
+	return _;
+}
+var $ZodAsyncError = class extends Error {
+	constructor() {
+		super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+	}
+};
+(_a$1 = globalThis).__zod_globalConfig ?? (_a$1.__zod_globalConfig = {});
+const globalConfig = globalThis.__zod_globalConfig;
+function config(newConfig) {
+	if (newConfig) Object.assign(globalConfig, newConfig);
+	return globalConfig;
+}
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/util.js
+function joinValues(array, separator = "|") {
+	return array.map((val) => stringifyPrimitive(val)).join(separator);
+}
+function jsonStringifyReplacer(_, value) {
+	if (typeof value === "bigint") return value.toString();
+	return value;
+}
+var Cached = class {
+	constructor(getter) {
+		this._getter = getter;
+		this._value = void 0;
+	}
+	get value() {
+		const getter = this._getter;
+		if (getter !== void 0) {
+			this._value = getter();
+			this._getter = void 0;
+		}
+		return this._value;
+	}
+};
+function cached(getter) {
+	return new Cached(getter);
+}
+function nullish(input) {
+	return input === null || input === void 0;
+}
+function cleanRegex(source) {
+	const start = source.startsWith("^") ? 1 : 0;
+	const end = source.endsWith("$") ? source.length - 1 : source.length;
+	return source.slice(start, end);
+}
+function assignProp(target, prop, value) {
+	Object.defineProperty(target, prop, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+	return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+function isPlainObject(o) {
+	if (isObject(o) === false) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	if (typeof ctor !== "function") return true;
+	const prot = ctor.prototype;
+	if (isObject(prot) === false) return false;
+	if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
+	return true;
+}
+function clone(inst, def, params) {
+	const cl = new inst._zod.constr(def ?? inst._zod.def);
+	if (!def || params?.parent) cl._zod.parent = inst;
+	return cl;
+}
+function normalizeParams(_params) {
+	const params = _params;
+	if (!params) return {};
+	if (typeof params === "string") return { error: () => params };
+	if (params?.message !== void 0) {
+		if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
+		params.error = params.message;
+	}
+	delete params.message;
+	if (typeof params.error === "string") return {
+		...params,
+		error: () => params.error
+	};
+	return params;
+}
+function stringifyPrimitive(value) {
+	if (typeof value === "bigint") return value.toString() + "n";
+	if (typeof value === "string") return `"${value}"`;
+	return `${value}`;
+}
+function optionalKeys(shape) {
+	return Object.keys(shape).filter((k) => {
+		return shape[k]._zod.optin !== void 0 && shape[k]._zod.optout === "optional";
+	});
+}
+const NUMBER_FORMAT_RANGES = /*@__PURE__*/ (() => ({
+	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+	int32: [-2147483648, 2147483647],
+	uint32: [0, 4294967295],
+	float32: [-34028234663852886e22, 34028234663852886e22],
+	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+}))();
+function aborted(x, startIndex = 0) {
+	if (x.aborted === true) return true;
+	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
+	return false;
+}
+function explicitlyAborted(x, startIndex = 0) {
+	if (x.aborted === true) return true;
+	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue === false) return true;
+	return false;
+}
+function prefixIssues(path, issues) {
+	return issues.map((iss) => {
+		var _a;
+		(_a = iss).path ?? (_a.path = []);
+		iss.path.unshift(path);
+		return iss;
+	});
+}
+function unwrapMessage(message) {
+	return typeof message === "string" ? message : message?.message;
+}
+function attachSchema(issues, start, inst) {
+	var _a;
+	for (let i = start; i < issues.length; i++) (_a = issues[i]).schema ?? (_a.schema = inst);
+}
+function finalizeIssue(iss, ctx, config) {
+	var _a;
+	const traits = iss.inst?._zod?.traits;
+	if (traits?.has("$ZodType")) {
+		if (traits.has("$ZodCheck")) (_a = iss).schema ?? (_a.schema = iss.inst);
+		else iss.schema = iss.inst;
+	}
+	const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : void 0;
+	const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+	const full = {};
+	for (const k of Object.keys(iss)) {
+		if (k === "inst" || k === "schema" || k === "continue" || k === "input" || k === "__proto__") continue;
+		full[k] = iss[k];
+	}
+	full.path ?? (full.path = []);
+	full.message = message;
+	if (ctx?.reportInput) full.input = iss.input;
+	return full;
+}
+const highSurrogate = /[\uD800-\uDBFF]/;
+function codePointLength(str) {
+	const units = str.length;
+	if (!highSurrogate.test(str)) return units;
+	let count = units;
+	for (let i = 0; i < units - 1; i++) if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
+		count--;
+		i++;
+	}
+	return count;
+}
+function getLengthableOrigin(input) {
+	if (Array.isArray(input)) return "array";
+	if (typeof input === "string") return "string";
+	return "unknown";
+}
+function parsedType(data) {
+	const t = typeof data;
+	switch (t) {
+		case "number": return Number.isNaN(data) ? "nan" : "number";
+		case "object": {
+			if (data === null) return "null";
+			if (Array.isArray(data)) return "array";
+			const obj = data;
+			if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) return obj.constructor.name;
+		}
+	}
+	return t;
+}
+/**
+* Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.
+*
+* Call this from a `proto` initializer, which runs once per prototype — never per instance.
+*/
+function members(proto, table) {
+	for (const key in table) {
+		const desc = Object.getOwnPropertyDescriptor(table, key);
+		if (desc.get) Object.defineProperty(proto, key, {
+			...desc,
+			enumerable: false
+		});
+		else defineBound(proto, key, desc.value);
+	}
+}
+/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
+function own(inst, key, value, enumerable = true) {
+	Object.defineProperty(inst, key, {
+		configurable: true,
+		writable: true,
+		enumerable,
+		value
+	});
+	return value;
+}
+/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
+function hide(inst, key, value) {
+	return own(inst, key, value, false);
+}
+function defineBound(proto, key, fn) {
+	Object.defineProperty(proto, key, {
+		configurable: true,
+		get() {
+			return this == null ? fn : own(this, key, fn.bind(this));
+		},
+		set(value) {
+			own(this, key, value);
+		}
+	});
+}
+/** Returns the prototype to install on, or `undefined` if this group is already installed on it. */
+function claim(inst, sentinel) {
+	const proto = Object.getPrototypeOf(inst);
+	return sentinel in proto ? void 0 : proto;
+}
+let installing;
+let broke = false;
+const breaker = {
+	configurable: true,
+	get() {
+		broke = true;
+	}
+};
+/**
+* Installs a lazily-derived internal on the `_zod` prototype of `inst`'s
+* constructor, computed from the internals object itself and cached there on
+* first read. One accessor per constructor rather than one per instance.
+*/
+function defineLazyInternal(inst, key, compute) {
+	const proto = Object.getPrototypeOf(inst._zod);
+	if (key in proto && installing !== inst._zod) {
+		installing = void 0;
+		return;
+	}
+	installing = inst._zod;
+	Object.defineProperty(proto, key, {
+		configurable: true,
+		get() {
+			Object.defineProperty(this, key, breaker);
+			const outer = broke;
+			broke = false;
+			try {
+				const value = compute(this);
+				if (broke) delete this[key];
+				else Object.defineProperty(this, key, {
+					configurable: true,
+					writable: true,
+					value
+				});
+				broke = broke || outer;
+				return value;
+			} catch (err) {
+				delete this[key];
+				broke = broke || outer;
+				throw err;
+			}
+		},
+		set(value) {
+			Object.defineProperty(this, key, {
+				configurable: true,
+				writable: true,
+				value
+			});
+		}
+	});
+}
+/**
+* Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own
+* data property. One accessor per constructor rather than one per instance, because an own accessor
+* puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.
+*/
+function installLazyProp(inst, key, make, enumerable) {
+	const proto = claim(inst, key);
+	if (!proto) return;
+	Object.defineProperty(proto, key, {
+		configurable: true,
+		get() {
+			const desc = {
+				configurable: true,
+				writable: true,
+				enumerable,
+				value: void 0
+			};
+			Object.defineProperty(this, key, desc);
+			desc.value = make(this);
+			Object.defineProperty(this, key, desc);
+			return desc.value;
+		},
+		set(value) {
+			Object.defineProperty(this, key, {
+				configurable: true,
+				writable: true,
+				enumerable,
+				value
+			});
+		}
+	});
+}
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/en.js
+const error = () => {
+	const Sizable = {
+		string: {
+			unit: "characters",
+			verb: "to have"
+		},
+		file: {
+			unit: "bytes",
+			verb: "to have"
+		},
+		array: {
+			unit: "items",
+			verb: "to have"
+		},
+		set: {
+			unit: "items",
+			verb: "to have"
+		},
+		map: {
+			unit: "entries",
+			verb: "to have"
+		}
+	};
+	function getSizing(origin) {
+		return Sizable[origin] ?? null;
+	}
+	const FormatDictionary = {
+		regex: "input",
+		email: "email address",
+		url: "URL",
+		emoji: "emoji",
+		uuid: "UUID",
+		uuidv4: "UUIDv4",
+		uuidv6: "UUIDv6",
+		nanoid: "nanoid",
+		guid: "GUID",
+		cuid: "cuid",
+		cuid2: "cuid2",
+		ulid: "ULID",
+		xid: "XID",
+		ksuid: "KSUID",
+		datetime: "ISO datetime",
+		date: "ISO date",
+		time: "ISO time",
+		duration: "ISO duration",
+		ipv4: "IPv4 address",
+		ipv6: "IPv6 address",
+		mac: "MAC address",
+		cidrv4: "IPv4 range",
+		cidrv6: "IPv6 range",
+		base64: "base64-encoded string",
+		base64url: "base64url-encoded string",
+		json_string: "JSON string",
+		e164: "E.164 number",
+		currency_code: "currency code",
+		credit_card: "credit card number",
+		iban: "IBAN",
+		jwt: "JWT",
+		template_literal: "input"
+	};
+	const TypeDictionary = { nan: "NaN" };
+	function getTypeName(type, input) {
+		if (type === "number" && typeof input === "number" && !Number.isFinite(input)) return String(input);
+		return TypeDictionary[type] ?? type;
+	}
+	return (issue) => {
+		switch (issue.code) {
+			case "invalid_type": return `Invalid input: expected ${getTypeName(issue.expected)}, received ${getTypeName(parsedType(issue.input), issue.input)}`;
+			case "invalid_value":
+				if (issue.values.length === 1) return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
+				return `Invalid option: expected one of ${joinValues(issue.values, "|")}`;
+			case "too_big": {
+				const adj = issue.exact ? "exactly " : issue.inclusive ? "<=" : "<";
+				const sizing = getSizing(issue.origin);
+				if (sizing) return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
+				return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
+			}
+			case "too_small": {
+				const adj = issue.exact ? "exactly " : issue.inclusive ? ">=" : ">";
+				const sizing = getSizing(issue.origin);
+				if (sizing) return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+				return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
+			}
+			case "invalid_format": {
+				const _issue = issue;
+				if (_issue.format === "starts_with") return `Invalid string: must start with "${_issue.prefix}"`;
+				if (_issue.format === "ends_with") return `Invalid string: must end with "${_issue.suffix}"`;
+				if (_issue.format === "includes") return `Invalid string: must include "${_issue.includes}"`;
+				if (_issue.format === "regex") return `Invalid string: must match pattern ${_issue.pattern}`;
+				return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
+			}
+			case "not_multiple_of": return `Invalid number: must be a multiple of ${issue.divisor}`;
+			case "unrecognized_keys": return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
+			case "invalid_key": return `Invalid key in ${issue.origin}`;
+			case "invalid_union":
+				if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) return `Invalid discriminator value. Expected ${issue.options.map((o) => `'${o}'`).join(" | ")}`;
+				if (issue.inclusive === false) return "Invalid input: more than one option matched";
+				return "Invalid input";
+			case "invalid_element": return `Invalid value in ${issue.origin}`;
+			default: return `Invalid input`;
+		}
+	};
+};
+function en_default() {
+	return { localeError: error() };
+}
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/errors.js
+function _getMessage() {
+	const internals = this._zod;
+	internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
+	return internals.message;
+}
+function _setMessage(value) {
+	this._zod.message = value;
+}
+const _messageDesc = {
+	get: _getMessage,
+	set: _setMessage,
+	enumerable: true,
+	configurable: true
+};
+const _issuesDesc = {
+	value: void 0,
+	enumerable: false
+};
+const _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
+const initializer = (inst, def) => {
+	inst.name = "$ZodError";
+	_issuesDesc.value = def;
+	Object.defineProperty(inst, "issues", _issuesDesc);
+	_issuesDesc.value = void 0;
+	Object.defineProperty(inst, "message", _messageDesc);
+	const proto = Object.getPrototypeOf(inst);
+	if (!_installedToString.has(proto)) {
+		_installedToString.add(proto);
+		Object.defineProperty(proto, "toString", {
+			configurable: true,
+			enumerable: false,
+			get() {
+				const value = () => this.message;
+				Object.defineProperty(this, "toString", {
+					value,
+					configurable: true,
+					writable: true
+				});
+				return value;
+			},
+			set(value) {
+				Object.defineProperty(this, "toString", {
+					value,
+					configurable: true,
+					writable: true
+				});
+			}
+		});
+	}
+};
+const $ZodRealError = /* @__PURE__ */ $constructor("$ZodError", initializer, void 0, { Parent: Error });
+/** Format a ZodError as a human-readable string in the following form.
+*
+* From
+*
+* ```ts
+* ZodError {
+*   issues: [
+*     {
+*       expected: 'string',
+*       code: 'invalid_type',
+*       path: [ 'username' ],
+*       message: 'Invalid input: expected string'
+*     },
+*     {
+*       expected: 'number',
+*       code: 'invalid_type',
+*       path: [ 'favoriteNumbers', 1 ],
+*       message: 'Invalid input: expected number'
+*     }
+*   ];
+* }
+* ```
+*
+* to
+*
+* ```
+* username
+*   ✖ Expected number, received string at "username
+* favoriteNumbers[0]
+*   ✖ Invalid input: expected number
+* ```
+*/
+function toDotPath(_path) {
+	const segs = [];
+	const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+	for (const seg of path) if (typeof seg === "number") segs.push(`[${seg}]`);
+	else if (typeof seg === "symbol") segs.push(`[${JSON.stringify(String(seg))}]`);
+	else if (/[^\w$]/.test(seg)) segs.push(`[${JSON.stringify(seg)}]`);
+	else {
+		if (segs.length) segs.push(".");
+		segs.push(seg);
+	}
+	return segs.join("");
+}
+function prettifyError(error) {
+	const lines = [];
+	const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+	for (const issue of issues) {
+		lines.push(`✖ ${issue.message}`);
+		if (issue.path?.length) lines.push(`  → at ${toDotPath(issue.path)}`);
+	}
+	return lines.join("\n");
+}
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/parse.js
+const _parse = (_Err) => {
+	const fn = (schema, value, _ctx, _params) => {
+		const ctx = _ctx ? {
+			..._ctx,
+			async: false
+		} : { async: false };
+		const result = schema._zod.run({
+			value,
+			issues: []
+		}, ctx);
+		if (result instanceof Promise) throw new $ZodAsyncError();
+		if (result.issues.length) {
+			const e = new ((_params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+			captureStackTrace(e, _params?.callee ?? fn);
+			throw e;
+		}
+		return result.value;
+	};
+	return fn;
+};
+const parse = /* @__PURE__*/ _parse($ZodRealError);
+const _parseAsync = (_Err) => {
+	const fn = async (schema, value, _ctx, params) => {
+		const ctx = _ctx ? {
+			..._ctx,
+			async: true
+		} : { async: true };
+		let result = schema._zod.run({
+			value,
+			issues: []
+		}, ctx);
+		if (result instanceof Promise) result = await result;
+		if (result.issues.length) {
+			const e = new ((params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+			captureStackTrace(e, params?.callee ?? fn);
+			throw e;
+		}
+		return result.value;
+	};
+	return fn;
+};
+const parseAsync = /* @__PURE__*/ _parseAsync($ZodRealError);
+const _safeParse = (_Err) => (schema, value, _ctx) => {
+	const ctx = _ctx ? {
+		..._ctx,
+		async: false
+	} : { async: false };
+	const result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) throw new $ZodAsyncError();
+	return result.issues.length ? failure(_Err, result.issues, ctx) : {
+		success: true,
+		data: result.value
+	};
+};
+const safeParse = /* @__PURE__*/ _safeParse($ZodRealError);
+function failure(Err, issues, ctx) {
+	let error;
+	return {
+		success: false,
+		get error() {
+			if (!error) {
+				error = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));
+				issues = void 0;
+				ctx = void 0;
+			}
+			return error;
+		},
+		set error(e) {
+			error = e;
+			issues = void 0;
+			ctx = void 0;
+		}
+	};
+}
+const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+	const ctx = _ctx ? {
+		..._ctx,
+		async: true
+	} : { async: true };
+	let result = schema._zod.run({
+		value,
+		issues: []
+	}, ctx);
+	if (result instanceof Promise) result = await result;
+	return result.issues.length ? failure(_Err, result.issues, ctx) : {
+		success: true,
+		data: result.value
+	};
+};
+const safeParseAsync = /* @__PURE__*/ _safeParseAsync($ZodRealError);
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/regexes.js
+const anyString = /^[\s\S]{0,}$/;
+const number$1 = /^-?\d+(?:\.\d+)?$/;
+const boolean$1 = /^(?:true|false)$/i;
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/checks.js
+const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def) => {
+	var _a;
+	inst._zod ?? (inst._zod = {});
+	inst._zod.def = def;
+	(_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+/** Default `when` for length-based checks: run only on non-nullish values with a `length`. */
+const _whenHasLength = (payload) => {
+	const val = payload.value;
+	return !nullish(val) && val.length !== void 0;
+};
+const numericOriginMap = {
+	number: "number",
+	bigint: "bigint",
+	object: "date"
+};
+const $ZodCheckLessThan = /*@__PURE__*/ $constructor("$ZodCheckLessThan", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const origin = numericOriginMap[typeof def.value];
+	inst._zod.check = (payload) => {
+		if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
+		payload.issues.push({
+			origin: numericOriginMap[typeof payload.value] ?? origin,
+			code: "too_big",
+			maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+			input: payload.value,
+			inclusive: def.inclusive,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckGreaterThan = /*@__PURE__*/ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const origin = numericOriginMap[typeof def.value];
+	inst._zod.check = (payload) => {
+		if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
+		payload.issues.push({
+			origin: numericOriginMap[typeof payload.value] ?? origin,
+			code: "too_small",
+			minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+			input: payload.value,
+			inclusive: def.inclusive,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckNumberFormat = /*@__PURE__*/ $constructor("$ZodCheckNumberFormat", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	def.format = def.format || "float64";
+	const isInt = def.format?.includes("int");
+	const origin = isInt ? "int" : "number";
+	const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		if (isInt) {
+			if (!Number.isInteger(input)) {
+				payload.issues.push({
+					expected: origin,
+					format: def.format,
+					code: "invalid_type",
+					continue: false,
+					input,
+					inst
+				});
+				return;
+			}
+			if (!Number.isSafeInteger(input)) {
+				if (input > 0) payload.issues.push({
+					input,
+					code: "too_big",
+					maximum: Number.MAX_SAFE_INTEGER,
+					note: "Integers must be within the safe integer range.",
+					inst,
+					origin,
+					inclusive: true,
+					continue: !def.abort
+				});
+				else payload.issues.push({
+					input,
+					code: "too_small",
+					minimum: Number.MIN_SAFE_INTEGER,
+					note: "Integers must be within the safe integer range.",
+					inst,
+					origin,
+					inclusive: true,
+					continue: !def.abort
+				});
+				return;
+			}
+		}
+		if (input < minimum) payload.issues.push({
+			origin: "number",
+			input,
+			code: "too_small",
+			minimum,
+			inclusive: true,
+			inst,
+			continue: !def.abort
+		});
+		if (input > maximum) payload.issues.push({
+			origin: "number",
+			input,
+			code: "too_big",
+			maximum,
+			inclusive: true,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckMinLength = /*@__PURE__*/ $constructor("$ZodCheckMinLength", (inst, def) => {
+	var _a;
+	$ZodCheck.init(inst, def);
+	(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		const units = input.length;
+		if ((typeof input === "string" && units >= def.minimum && units < def.minimum * 2 ? codePointLength(input) : units) >= def.minimum) return;
+		const origin = getLengthableOrigin(input);
+		payload.issues.push({
+			origin,
+			code: "too_small",
+			minimum: def.minimum,
+			inclusive: true,
+			input,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckStringFormat = /*@__PURE__*/ $constructor("$ZodCheckStringFormat", (inst, def) => {
+	var _a, _b;
+	$ZodCheck.init(inst, def);
+	if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: def.format,
+			input: payload.value,
+			...def.pattern ? { pattern: def.pattern.toString() } : {},
+			inst,
+			continue: !def.abort
+		});
+	});
+	else (_b = inst._zod).check ?? (_b.check = () => {});
+});
+const $ZodCheckRegex = /*@__PURE__*/ $constructor("$ZodCheckRegex", (inst, def) => {
+	$ZodCheckStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "regex",
+			input: payload.value,
+			pattern: def.pattern.toString(),
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/versions.js
+const version = {
+	major: 4,
+	minor: 6,
+	patch: 7
+};
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/schemas.js
+const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
+	var _a;
+	inst ?? (inst = {});
+	inst._zod.def = def;
+	inst._zod.bag = inst._zod.bag || {};
+	inst._zod.version = version;
+	const defChecks = inst._zod.def.checks;
+	const checks = inst._zod.traits.has("$ZodCheck") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];
+	for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);
+	if (checks.length === 0) {
+		(_a = inst._zod).deferred ?? (_a.deferred = []);
+		inst._zod.deferred?.push(() => {
+			inst._zod.run = inst._zod.parse;
+		});
+	} else {
+		const runChecks = (payload, checks, ctx) => {
+			if (payload.memo) return payload;
+			let isAborted = aborted(payload);
+			let asyncResult;
+			for (const ch of checks) {
+				if (ch._zod.def.when) {
+					if (explicitlyAborted(payload)) continue;
+					if (!ch._zod.def.when(payload)) continue;
+				} else if (isAborted) continue;
+				const currLen = payload.issues.length;
+				const _ = ch._zod.check(payload);
+				if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();
+				if (asyncResult || _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+					await _;
+					if (payload.issues.length === currLen) return;
+					attachSchema(payload.issues, currLen, inst);
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				});
+				else {
+					if (payload.issues.length === currLen) continue;
+					attachSchema(payload.issues, currLen, inst);
+					if (!isAborted) isAborted = aborted(payload, currLen);
+				}
+			}
+			if (asyncResult) return asyncResult.then(() => {
+				return payload;
+			});
+			return payload;
+		};
+		const handleCanaryResult = (canary, payload, ctx) => {
+			if (aborted(canary)) {
+				canary.aborted = true;
+				return canary;
+			}
+			const checkResult = runChecks(payload, checks, ctx);
+			if (checkResult instanceof Promise) {
+				if (ctx.async === false) throw new $ZodAsyncError();
+				return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
+			}
+			return inst._zod.parse(checkResult, ctx);
+		};
+		inst._zod.run = (payload, ctx) => {
+			if (ctx.skipChecks) return inst._zod.parse(payload, ctx);
+			if (ctx.direction === "backward") {
+				const canary = inst._zod.parse({
+					value: payload.value,
+					issues: []
+				}, {
+					...ctx,
+					skipChecks: true
+				});
+				if (canary instanceof Promise) return canary.then((canary) => {
+					return handleCanaryResult(canary, payload, ctx);
+				});
+				return handleCanaryResult(canary, payload, ctx);
+			}
+			const result = inst._zod.parse(payload, ctx);
+			if (result instanceof Promise) {
+				if (ctx.async === false) throw new $ZodAsyncError();
+				return result.then((result) => runChecks(result, checks, ctx));
+			}
+			return runChecks(result, checks, ctx);
+		};
+	}
+}, {
+	get "~standard"() {
+		return hide(this, "~standard", standardProps(this));
+	},
+	set "~standard"(value) {
+		own(this, "~standard", value);
+	}
+});
+/** The Standard Schema surface for `inst`. Shared so wrappers can extend it without forcing it. */
+const toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value };
+async function validateAsync(inst, value) {
+	const ctx = { async: true };
+	return toStandardResult(await inst._zod.run({
+		value,
+		issues: []
+	}, ctx), ctx);
+}
+function standardProps(inst) {
+	return {
+		validate: (value) => {
+			const ctx = { async: false };
+			try {
+				const r = inst._zod.run({
+					value,
+					issues: []
+				}, ctx);
+				if (!(r instanceof Promise)) return toStandardResult(r, ctx);
+			} catch (_) {}
+			return validateAsync(inst, value);
+		},
+		vendor: "zod",
+		version: 1
+	};
+}
+const $ZodString = /*@__PURE__*/ $constructor("$ZodString", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = def.pattern ?? anyString;
+	inst._zod.parse = (payload, _) => {
+		if (def.coerce) try {
+			payload.value = String(payload.value);
+		} catch (_) {}
+		if (typeof payload.value === "string") return payload;
+		payload.issues.push({
+			expected: "string",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = number$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Number(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
+		const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? String(input) : void 0 : void 0;
+		payload.issues.push({
+			expected: "number",
+			code: "invalid_type",
+			input,
+			inst,
+			...received ? { received } : {}
+		});
+		return payload;
+	};
+});
+const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumberFormat", (inst, def) => {
+	$ZodCheckNumberFormat.init(inst, def);
+	$ZodNumber.init(inst, def);
+});
+const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = boolean$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Boolean(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "boolean") return payload;
+		payload.issues.push({
+			expected: "boolean",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodNever = /*@__PURE__*/ $constructor("$ZodNever", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		payload.issues.push({
+			expected: "never",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+function handlePropertyResult(result, final, key, input, optin, optout) {
+	const isPresent = key in input;
+	const isOptionalOut = optout === "optional";
+	if (!isPresent && isOptionalOut && optin === "optional") return;
+	if (result.issues.length) {
+		if (optin !== void 0 && isOptionalOut && !isPresent) return;
+		final.issues.push(...prefixIssues(key, result.issues));
+	}
+	if (!isPresent && optin === void 0) {
+		if (!result.issues.length) final.issues.push({
+			code: "invalid_type",
+			expected: "nonoptional",
+			input: void 0,
+			path: [key]
+		});
+		return;
+	}
+	if (result.value === void 0) {
+		if (isPresent || optin === "defaulted" && !isOptionalOut) final.value[key] = void 0;
+	} else final.value[key] = result.value;
+}
+const NO_SYMBOL_KEYS = [];
+function normalizeDef(def) {
+	const keys = Object.keys(def.shape);
+	const ownSymbols = Object.getOwnPropertySymbols(def.shape);
+	const symbolKeys = ownSymbols.length ? ownSymbols : NO_SYMBOL_KEYS;
+	const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;
+	for (const k of allKeys) if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${String(k)}": expected a Zod schema`);
+	const okeys = optionalKeys(def.shape);
+	return {
+		...def,
+		allKeys,
+		symbolKeys,
+		keySet: new Set(keys),
+		numKeys: keys.length,
+		optionalKeys: new Set(okeys)
+	};
+}
+function handleCatchall(proms, input, payload, ctx, def, inst, abortEarly) {
+	const unrecognized = [];
+	const keySet = def.keySet;
+	const _catchall = def.catchall._zod;
+	const t = _catchall.def.type;
+	const optin = _catchall.optin;
+	const optout = _catchall.optout;
+	let seen = 0;
+	for (const key in input) {
+		if (abortEarly && payload.issues.length !== seen) {
+			if (aborted(payload, seen)) break;
+			seen = payload.issues.length;
+		}
+		if (keySet.has(key)) continue;
+		if (key === "__proto__") {
+			if (t === "never") unrecognized.push(key);
+			continue;
+		}
+		if (t === "never") {
+			unrecognized.push(key);
+			continue;
+		}
+		const r = _catchall.run({
+			value: input[key],
+			issues: []
+		}, ctx);
+		if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));
+		else handlePropertyResult(r, payload, key, input, optin, optout);
+	}
+	if (unrecognized.length) payload.issues.push({
+		code: "unrecognized_keys",
+		keys: unrecognized,
+		input,
+		inst,
+		continue: true
+	});
+	if (!proms.length) return payload;
+	return Promise.all(proms).then(() => {
+		return payload;
+	});
+}
+const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
+	$ZodType.init(inst, def);
+	const desc = Object.getOwnPropertyDescriptor(def, "shape");
+	const sh = desc?.get ? desc.get.raw : def.shape ?? {};
+	if (sh) {
+		const get = () => {
+			const newSh = { ...sh };
+			Object.defineProperty(def, "shape", { value: newSh });
+			get.raw = newSh;
+			return newSh;
+		};
+		get.raw = sh;
+		Object.defineProperty(def, "shape", { get });
+	}
+	const _normalized = cached(() => normalizeDef(def));
+	defineLazyInternal(inst, "propValues", (zod) => {
+		const shape = zod.def.shape;
+		const propValues = {};
+		for (const key in shape) {
+			const field = shape[key]._zod;
+			if (field.values) {
+				if (!Object.prototype.hasOwnProperty.call(propValues, key)) assignProp(propValues, key, /* @__PURE__ */ new Set());
+				for (const v of field.values) propValues[key].add(v);
+				if (field.optin !== void 0) propValues[key].add(void 0);
+			}
+		}
+		return propValues;
+	});
+	const isObject$1 = isObject;
+	const catchall = def.catchall;
+	let value;
+	const memo = globalConfig.memoizer;
+	memo?.attach(inst);
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$1(input)) {
+			payload.issues.push({
+				expected: "object",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};
+		const proms = [];
+		const shape = value.shape;
+		const abortEarly = ctx?.abortEarly;
+		let seen = payload.issues.length;
+		for (const key of value.allKeys) {
+			if (abortEarly && payload.issues.length !== seen) {
+				if (aborted(payload, seen)) break;
+				seen = payload.issues.length;
+			}
+			if (key === "__proto__") continue;
+			const el = shape[key];
+			const optin = el._zod.optin;
+			const optout = el._zod.optout;
+			const r = el._zod.run({
+				value: input[key],
+				issues: []
+			}, ctx);
+			if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));
+			else handlePropertyResult(r, payload, key, input, optin, optout);
+		}
+		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
+		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst, abortEarly === true);
+	};
+});
+const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	const memo = globalConfig.memoizer;
+	memo?.attach(inst);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values && !def.partial) {
+			payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				if (key === "__proto__") continue;
+				const keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (keyResult.issues.length) {
+					payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const outKey = keyResult.value;
+				if (outKey === "__proto__") continue;
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[outKey] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[outKey] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				if (def.mode === "loose") {
+					if (key === "__proto__") continue;
+					payload.value[key] = input[key];
+				} else {
+					unrecognized = unrecognized ?? [];
+					unrecognized.push(key);
+				}
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized,
+				continue: true
+			});
+		} else {
+			payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};
+			let unrecognized;
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				if (!Object.prototype.propertyIsEnumerable.call(input, key)) continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else if (values) {
+						unrecognized = unrecognized ?? [];
+						unrecognized.push(key);
+					} else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const outKey = keyResult.value;
+				if (outKey === "__proto__") continue;
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[outKey] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[outKey] = result.value;
+				}
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized,
+				continue: true
+			});
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+function handleOptionalResult(payload, result) {
+	payload.value = result.issues.length ? void 0 : result.value;
+	return payload;
+}
+const $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def) => {
+	$ZodType.init(inst, def);
+	defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin === "defaulted" ? "defaulted" : "optional");
+	inst._zod.optout = "optional";
+	defineLazyInternal(inst, "values", (zod) => {
+		const values = zod.def.innerType._zod.values;
+		return values ? /* @__PURE__ */ new Set([...values, void 0]) : void 0;
+	});
+	defineLazyInternal(inst, "pattern", (zod) => {
+		const pattern = zod.def.innerType._zod.pattern;
+		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		if (payload.value === void 0) {
+			if (def.innerType._zod.optin !== "defaulted") return payload;
+			const result = def.innerType._zod.run({
+				value: payload.value,
+				issues: []
+			}, ctx);
+			if (result instanceof Promise) return result.then((result) => handleOptionalResult(payload, result));
+			return handleOptionalResult(payload, result);
+		}
+		return def.innerType._zod.run(payload, ctx);
+	};
+});
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/registries.js
+var _a;
+var $ZodRegistry = class {
+	constructor() {
+		this._map = /* @__PURE__ */ new WeakMap();
+		this._idmap = /* @__PURE__ */ new Map();
+	}
+	add(schema, ..._meta) {
+		const meta = _meta[0];
+		this._map.set(schema, meta);
+		if (meta && typeof meta === "object" && "id" in meta) this._idmap.set(meta.id, schema);
+		return this;
+	}
+	clear() {
+		this._map = /* @__PURE__ */ new WeakMap();
+		this._idmap = /* @__PURE__ */ new Map();
+		return this;
+	}
+	remove(schema) {
+		const meta = this._map.get(schema);
+		if (meta && typeof meta === "object" && "id" in meta) this._idmap.delete(meta.id);
+		this._map.delete(schema);
+		return this;
+	}
+	get(schema) {
+		const p = schema._zod.parent;
+		if (p) {
+			const pm = { ...this.get(p) ?? {} };
+			delete pm.id;
+			const f = {
+				...pm,
+				...this._map.get(schema)
+			};
+			return Object.keys(f).length ? f : void 0;
+		}
+		return this._map.get(schema);
+	}
+	has(schema) {
+		return this._map.has(schema);
+	}
+};
+function registry() {
+	return new $ZodRegistry();
+}
+(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+const globalRegistry = globalThis.__zod_globalRegistry;
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/api.js
+function snapshotChecks(def) {
+	if (def.checks) def.checks = [...def.checks];
+	return def;
+}
+// @__NO_SIDE_EFFECTS__
+function _string(Class, params) {
+	return new Class(snapshotChecks({
+		type: "string",
+		...normalizeParams(params)
+	}));
+}
+// @__NO_SIDE_EFFECTS__
+function _number(Class, params) {
+	return new Class(snapshotChecks({
+		type: "number",
+		checks: [],
+		...normalizeParams(params)
+	}));
+}
+// @__NO_SIDE_EFFECTS__
+function _int(Class, params) {
+	return new Class({
+		type: "number",
+		check: "number_format",
+		abort: false,
+		format: "safeint",
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _boolean(Class, params) {
+	return new Class({
+		type: "boolean",
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _never(Class, params) {
+	return new Class({
+		type: "never",
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _lte(value, params) {
+	return new $ZodCheckLessThan({
+		check: "less_than",
+		...normalizeParams(params),
+		value,
+		inclusive: true
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _gt(value, params) {
+	return new $ZodCheckGreaterThan({
+		check: "greater_than",
+		...normalizeParams(params),
+		value,
+		inclusive: false
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _gte(value, params) {
+	return new $ZodCheckGreaterThan({
+		check: "greater_than",
+		...normalizeParams(params),
+		value,
+		inclusive: true
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _positive(params) {
+	return /* @__PURE__ */ _gt(0, params);
+}
+// @__NO_SIDE_EFFECTS__
+function _minLength(minimum, params) {
+	return new $ZodCheckMinLength({
+		check: "min_length",
+		...normalizeParams(params),
+		minimum
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _regex(pattern, params) {
+	return new $ZodCheckRegex({
+		check: "string_format",
+		format: "regex",
+		...normalizeParams(params),
+		pattern
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function describe$2(description) {
+	const ch = new $ZodCheck({ check: "describe" });
+	ch._zod.onattach = [(inst) => {
+		const existing = globalRegistry.get(inst) ?? {};
+		globalRegistry.add(inst, {
+			...existing,
+			description
+		});
+	}];
+	ch._zod.check = () => {};
+	return ch;
+}
+// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/mini/schemas.js
+const ZodMiniType = /*@__PURE__*/ $constructor("ZodMiniType", (inst, def) => {
+	if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
+	$ZodType.init(inst, def);
+	inst.def = def;
+	inst.type = def.type;
+}, {
+	get with() {
+		return this.check;
+	},
+	set with(value) {
+		own(this, "with", value);
+	},
+	parse(data, params) {
+		return parse(this, data, params, { callee: this.parse });
+	},
+	parseAsync(data, params) {
+		return parseAsync(this, data, params, { callee: this.parseAsync });
+	},
+	safeParse(data, params) {
+		return safeParse(this, data, params);
+	},
+	safeParseAsync(data, params) {
+		return safeParseAsync(this, data, params);
+	},
+	check(...checks) {
+		const def = this.def;
+		return this.clone({
+			...def,
+			checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
+				check: ch,
+				def: { check: "custom" },
+				onattach: []
+			} } : ch)]
+		}, { parent: true });
+	},
+	clone(_def, params) {
+		return clone(this, _def, params);
+	},
+	brand() {
+		return this;
+	},
+	register(reg, meta) {
+		reg.add(this, meta);
+		return this;
+	},
+	apply(fn, ...args) {
+		return args.length === 0 ? fn(this) : fn(this, ...args);
+	}
+});
+const ZodMiniString = /*@__PURE__*/ $constructor("ZodMiniString", (inst, def) => {
+	$ZodString.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function string(params) {
+	return /* @__PURE__ */ _string(ZodMiniString, params);
+}
+const ZodMiniNumber = /*@__PURE__*/ $constructor("ZodMiniNumber", (inst, def) => {
+	$ZodNumber.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function number(params) {
+	return /* @__PURE__ */ _number(ZodMiniNumber, params);
+}
+const ZodMiniNumberFormat = /*@__PURE__*/ $constructor("ZodMiniNumberFormat", (inst, def) => {
+	$ZodNumberFormat.init(inst, def);
+	ZodMiniNumber.init(inst, def);
+});
+function int(params) {
+	return /* @__PURE__ */ _int(ZodMiniNumberFormat, params);
+}
+const ZodMiniBoolean = /*@__PURE__*/ $constructor("ZodMiniBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function boolean(params) {
+	return /* @__PURE__ */ _boolean(ZodMiniBoolean, params);
+}
+const ZodMiniNever = /*@__PURE__*/ $constructor("ZodMiniNever", (inst, def) => {
+	$ZodNever.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function never(params) {
+	return /* @__PURE__ */ _never(ZodMiniNever, params);
+}
+const ZodMiniObject = /*@__PURE__*/ $constructor("ZodMiniObject", (inst, def) => {
+	$ZodObject.init(inst, def);
+	ZodMiniType.init(inst, def);
+	installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
+});
+// @__NO_SIDE_EFFECTS__
+function strictObject(shape, params) {
+	return new ZodMiniObject({
+		type: "object",
+		shape,
+		catchall: /* @__PURE__ */ never(),
+		...normalizeParams(params)
+	});
+}
+const ZodMiniRecord = /*@__PURE__*/ $constructor("ZodMiniRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function record(keyType, valueType, params) {
+	if (!valueType || !valueType._zod) return new ZodMiniRecord({
+		type: "record",
+		keyType: /* @__PURE__ */ string(),
+		valueType: keyType,
+		...normalizeParams(valueType)
+	});
+	return new ZodMiniRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniOptional = /*@__PURE__*/ $constructor("ZodMiniOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function optional(innerType) {
+	return new ZodMiniOptional({
+		type: "optional",
+		innerType
+	});
+}
+const describe$1 = describe$2;
+// src/config.ts
+config(en_default());
+const CONFIG_FILE = "portcall.json";
+const DEFAULT_READY_TIMEOUT = 60;
+const nameSchema = (/* @__PURE__ */ string()).check(/* @__PURE__ */ _regex(/^\w[\w.-]*$/, "use letters, digits, dot, dash or underscore"));
+const serviceSchema = /* @__PURE__ */ strictObject({
+	command: (/* @__PURE__ */ optional((/* @__PURE__ */ string()).check(/* @__PURE__ */ _minLength(1)))).check(describe$1("Shell command that runs the service. Omit it for an external service (a database in Docker...): portcall then only checks its port.")),
+	port: int().check(/* @__PURE__ */ _gte(1), /* @__PURE__ */ _lte(65535), describe$1("Port the service listens on. Also passed to the command as PORT.")),
+	cwd: (/* @__PURE__ */ optional(/* @__PURE__ */ string())).check(describe$1("Directory to run the command in, relative to portcall.json. Default: the project root.")),
+	env: (/* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string()))).check(describe$1("Extra environment. {port} is this service's port, {ports.<service>} another service's.")),
+	readyTimeout: (/* @__PURE__ */ optional((/* @__PURE__ */ number()).check(/* @__PURE__ */ _positive()))).check(describe$1("Seconds `portcall up` waits for the port. Default: 60."))
+});
+const configSchema = /* @__PURE__ */ strictObject({
+	$schema: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	name: nameSchema.check(describe$1("Project name, used by `portcall -p <name>` and in the logs folder.")),
+	services: (/* @__PURE__ */ record(nameSchema, serviceSchema)).check(describe$1("The project's services, by name.")),
+	worktrees: (/* @__PURE__ */ optional(/* @__PURE__ */ boolean())).check(describe$1("Let each git worktree of the project run its services at the same time, on ports offset from the declared ones (external services keep theirs). Commands must take their port from PORT and {ports.<service>}. Default: false, all checkouts share the declared ports."))
+});
+var ConfigError = class extends Error {};
+function findConfig(from) {
+	let dir = resolve(from);
+	for (;;) {
+		const file = join(dir, CONFIG_FILE);
+		if (existsSync(file)) return file;
+		const parent = dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+}
+/** The worktree name when `dir` is inside a linked git worktree (not the main checkout). */
+function linkedWorktree(dir) {
+	for (let current = resolve(dir);;) {
+		const dotGit = join(current, ".git");
+		if (existsSync(dotGit)) {
+			let content;
+			try {
+				content = readFileSync(dotGit, "utf8");
+			} catch {
+				return;
+			}
+			const gitDir = /^gitdir: (.+)$/m.exec(content)?.[1]?.trim();
+			if (!gitDir) return void 0;
+			const resolved = resolve(current, gitDir);
+			return existsSync(join(resolved, "commondir")) ? basename(resolved) : void 0;
+		}
+		const parent = dirname(current);
+		if (parent === current) return void 0;
+		current = parent;
+	}
+}
+function loadProject(file, offsets = {}) {
+	let raw;
+	try {
+		raw = JSON.parse(readFileSync(file, "utf8"));
+	} catch (error) {
+		throw new ConfigError(`${file}: ${error.message}`);
+	}
+	return parseProject(raw, join(realpathSync(dirname(file)), basename(file)), offsets);
+}
+function parseProject(raw, file, offsets = {}) {
+	const parsed = configSchema.safeParse(raw);
+	if (!parsed.success) throw new ConfigError(`${file}:\n${prettifyError(parsed.error)}`);
+	const config = parsed.data;
+	const root = dirname(file);
+	const entries = Object.entries(config.services);
+	if (entries.length === 0) throw new ConfigError(`${file}: "services" is empty`);
+	const ports = /* @__PURE__ */ new Map();
+	for (const [name, service] of entries) {
+		const other = ports.get(service.port);
+		if (other) throw new ConfigError(`${file}: services "${other}" and "${name}" both use port ${service.port}`);
+		ports.set(service.port, name);
+	}
+	const worktree = config.worktrees ? linkedWorktree(root) : void 0;
+	const portOffset = worktree ? offsets[root] : void 0;
+	const effective = new Map(entries.map(([name, service]) => [name, service.port + (service.command ? portOffset ?? 0 : 0)]));
+	const services = entries.map(([name, service]) => ({
+		name,
+		port: effective.get(name),
+		basePort: service.port,
+		command: service.command,
+		cwd: resolve(root, service.cwd ?? "."),
+		env: expandEnv(service.env ?? {}, effective.get(name), effective, file, name),
+		readyTimeout: service.readyTimeout ?? DEFAULT_READY_TIMEOUT
+	}));
+	const instance = worktree ? `${config.name}@${worktree}` : config.name;
+	return {
+		name: config.name,
+		instance,
+		root,
+		file,
+		services,
+		...worktree ? {
+			worktree,
+			portOffset
+		} : {}
+	};
+}
+/** Fills `{port}` (this service) and `{ports.<service>}` (any service of the project). */
+function expandEnv(env, port, byName, file, service) {
+	const out = {};
+	for (const [key, value] of Object.entries(env)) out[key] = value.replace(/\{(port|ports\.([\w.-]+))\}/g, (_, whole, other) => {
+		if (whole === "port") return String(port);
+		const found = byName.get(other);
+		if (found === void 0) throw new ConfigError(`${file}: services.${service}.env.${key} refers to unknown service "${other}"`);
+		return String(found);
+	});
+	return out;
+}
+// src/logs.ts
+const LINE = /^(\d{4}-\d\d-\d\dT[\d:.]+Z) \[(\w+)\] (.*)$/;
+const ERROR = /(?:error|exception)\b|\b(?:fatal|panic|unhandled|traceback|failed)\b|ERR!/i;
+const CONTINUATION = /^\s|^(?:caused by|\} )/i;
+const MAX_CONTINUATION = 40;
+const MAX_READ = 8388608;
+function parseLine(raw, service) {
+	const match = LINE.exec(raw);
+	if (!match) return {
+		tag: "out",
+		text: raw,
+		service
+	};
+	return {
+		time: new Date(match[1]),
+		tag: match[2],
+		text: match[3],
+		service
+	};
+}
+/** `30s`, `5m`, `2h`, `1d`, or anything `Date.parse` reads. Returns epoch ms. */
+function parseSince(value, now = Date.now()) {
+	const match = /^(\d+)([smhd])$/.exec(value.trim());
+	if (match) {
+		const unit = {
+			s: 1e3,
+			m: 6e4,
+			h: 36e5,
+			d: 864e5
+		}[match[2]];
+		return now - Number(match[1]) * unit;
+	}
+	const time = Date.parse(value);
+	if (Number.isNaN(time)) throw new Error(`--since: can't read "${value}" (try 30s, 5m, 2h or a date)`);
+	return time;
+}
+function isError(line) {
+	if (line.tag === "portcall") return /^exited with|^failed to start/.test(line.text);
+	return ERROR.test(line.text);
+}
+function filterLines(lines, filter) {
+	let out = lines;
+	if (filter.since !== void 0) out = out.filter((line) => !line.time || line.time.getTime() >= filter.since);
+	if (filter.errors) {
+		const kept = [];
+		for (let i = 0; i < out.length; i++) {
+			if (!isError(out[i])) continue;
+			kept.push(out[i]);
+			let j = i + 1;
+			while (j < out.length && j - i <= MAX_CONTINUATION && CONTINUATION.test(out[j].text) && !isError(out[j])) kept.push(out[j++]);
+			i = j - 1;
+		}
+		out = kept;
+	}
+	if (filter.grep) out = out.filter((line) => filter.grep.test(line.text));
+	if (filter.limit !== void 0) out = out.slice(-filter.limit);
+	return out;
+}
+function readTail(file, maxBytes) {
+	const size = statSync(file).size;
+	const start = Math.max(0, size - maxBytes);
+	const buffer = Buffer.alloc(size - start);
+	const fd = openSync(file, "r");
+	try {
+		readSync(fd, buffer, 0, buffer.length, start);
+	} finally {
+		closeSync(fd);
+	}
+	const text = buffer.toString("utf8");
+	return start > 0 ? text.slice(text.indexOf("\n") + 1) : text;
+}
+function readLog(file, service) {
+	if (!existsSync(file)) return [];
+	return readTail(file, MAX_READ).split("\n").filter(Boolean).map((raw) => parseLine(raw, service));
+}
+/** Several services' logs as one, in time order. */
+function mergeLogs(logs) {
+	return logs.flat().sort((a, b) => (a.time?.getTime() ?? 0) - (b.time?.getTime() ?? 0));
+}
+function pad(n, width = 2) {
+	return String(n).padStart(width, "0");
+}
+function formatLine(line, serviceWidth = 0) {
+	return `${line.time ? `${pad(line.time.getHours())}:${pad(line.time.getMinutes())}:${pad(line.time.getSeconds())}.${pad(line.time.getMilliseconds(), 3)} ` : ""}${serviceWidth ? `${line.service.padEnd(serviceWidth)} ` : ""}${line.tag === "out" ? "" : `[${line.tag}] `}${line.text}`;
+}
+/** `tail -f` over several logs; a log that shrinks was rotated by a restart and is read again from its start. */
+async function followLogs(files, onLine, filter) {
+	const offsets = files.map(({ file }) => existsSync(file) ? statSync(file).size : 0);
+	const partial = files.map(() => "");
+	for (;;) {
+		for (const [i, { file, service }] of files.entries()) {
+			if (!existsSync(file)) continue;
+			const size = statSync(file).size;
+			if (size < offsets[i]) {
+				offsets[i] = 0;
+				partial[i] = "";
+			}
+			if (size === offsets[i]) continue;
+			const buffer = Buffer.alloc(size - offsets[i]);
+			const fd = openSync(file, "r");
+			try {
+				readSync(fd, buffer, 0, buffer.length, offsets[i]);
+			} finally {
+				closeSync(fd);
+			}
+			offsets[i] = size;
+			const chunks = (partial[i] + buffer.toString("utf8")).split("\n");
+			partial[i] = chunks.pop();
+			const lines = chunks.filter(Boolean).map((raw) => parseLine(raw, service));
+			for (const line of filterLines(lines, {
+				...filter,
+				limit: void 0,
+				since: void 0
+			})) onLine(line);
+		}
+		await setTimeout$1(250);
+	}
+}
+// src/paths.ts
+function portcallHome() {
+	return process.env.PORTCALL_HOME || join(homedir(), ".portcall");
+}
+function statePath() {
+	return join(portcallHome(), "state.json");
+}
+function projectsPath() {
+	return join(portcallHome(), "projects.json");
+}
+function logPath(project, service) {
+	return join(portcallHome(), "logs", project, `${service}.log`);
+}
+// src/ports.ts
+const exec = promisify(execFile);
+function canConnect(host, port, timeoutMs) {
+	return new Promise((resolve) => {
+		const socket = connect({
+			host,
+			port
+		});
+		const done = (ok) => {
+			socket.destroy();
+			resolve(ok);
+		};
+		socket.setTimeout(timeoutMs, () => done(false));
+		socket.once("connect", () => done(true));
+		socket.once("error", () => done(false));
+	});
+}
+/** Vite and friends often bind `::1` only, so both loopbacks are tried. */
+async function isListening(port, timeoutMs = 500) {
+	return (await Promise.all(["127.0.0.1", "::1"].map((host) => canConnect(host, port, timeoutMs)))).some(Boolean);
+}
+/** Best effort: needs `lsof`, and only sees processes of the current user. */
+async function portHolder(port) {
+	let stdout;
+	try {
+		({stdout} = await exec("lsof", [
+			"-nP",
+			`-iTCP:${port}`,
+			"-sTCP:LISTEN",
+			"-t"
+		]));
+	} catch {
+		return;
+	}
+	const pid = Number(stdout.trim().split("\n")[0]);
+	if (!pid) return void 0;
+	const [command, cwd] = await Promise.all([processCommand(pid), processCwd(pid)]);
+	return {
+		pid,
+		command,
+		cwd
+	};
+}
+async function processCommand(pid) {
+	try {
+		return (await exec("ps", [
+			"-o",
+			"command=",
+			"-p",
+			String(pid)
+		])).stdout.trim();
+	} catch {
+		return "";
+	}
+}
+async function processCwd(pid) {
+	try {
+		if (process.platform === "linux") return await readlink(`/proc/${pid}/cwd`);
+		const { stdout } = await exec("lsof", [
+			"-a",
+			"-p",
+			String(pid),
+			"-d",
+			"cwd",
+			"-Fn"
+		]);
+		return stdout.split("\n").find((line) => line.startsWith("n"))?.slice(1);
+	} catch {
+		return;
+	}
+}
+// src/proc.ts
+function isAlive(pid) {
+	if (!pid) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+function signal(pid, sig) {
+	if (!pid) return;
+	try {
+		process.kill(pid, sig);
+	} catch {}
+}
+/** Signals the whole process group led by `pid`: `pnpm dev` spawns its own children. */
+function signalGroup(pid, sig) {
+	if (pid) signal(-pid, sig);
+}
+async function waitForDeath(pid, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (isAlive(pid)) {
+		if (Date.now() > deadline) return false;
+		await setTimeout$1(50);
+	}
+	return true;
+}
+// src/state.ts
+const LOCK_WAIT_MS = 5e3;
+const STALE_LOCK_MS = 1e4;
+function recordKey(project, service) {
+	return `${project}/${service}`;
+}
+function readState() {
+	try {
+		const state = JSON.parse(readFileSync(statePath(), "utf8"));
+		if (state && typeof state.services === "object") return state;
+	} catch {}
+	return { services: {} };
+}
+async function updateState(fn) {
+	return withLock(() => {
+		const state = readState();
+		const result = fn(state);
+		writeJson(statePath(), state);
+		return result;
+	});
+}
+function writeJson(file, value) {
+	mkdirSync(portcallHome(), { recursive: true });
+	const tmp = `${file}.${process.pid}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`);
+	renameSync(tmp, file);
+}
+async function withLock(fn) {
+	mkdirSync(portcallHome(), { recursive: true });
+	const lock = join(portcallHome(), "state.lock");
+	const deadline = Date.now() + LOCK_WAIT_MS;
+	for (;;) try {
+		closeSync(openSync(lock, "wx"));
+		break;
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		try {
+			if (Date.now() - statSync(lock).mtimeMs > STALE_LOCK_MS) unlinkSync(lock);
+		} catch {}
+		if (Date.now() > deadline) throw new Error(`state is locked (${lock}); delete it if no portcall command is running`);
+		await setTimeout$1(20);
+	}
+	try {
+		return fn();
+	} finally {
+		try {
+			unlinkSync(lock);
+		} catch {}
+	}
+}
+function readRoots() {
+	try {
+		const roots = JSON.parse(readFileSync(projectsPath(), "utf8"));
+		if (Array.isArray(roots)) return roots.filter((r) => typeof r === "string");
+	} catch {}
+	return [];
+}
+/** Remembers a project so `status --all`, `ports` and `--project` find it from anywhere. */
+function rememberProject(root) {
+	const roots = readRoots();
+	if (!roots.includes(root)) writeJson(projectsPath(), [...roots, root].sort());
+}
+function knownProjects() {
+	const projects = [];
+	const errors = [];
+	const kept = [];
+	const roots = readRoots();
+	const offsets = readState().offsets;
+	for (const root of roots) {
+		const file = join(root, CONFIG_FILE);
+		if (!existsSync(file)) continue;
+		kept.push(root);
+		try {
+			projects.push(loadProject(file, offsets));
+		} catch (error) {
+			errors.push(error.message);
+		}
+	}
+	if (kept.length !== roots.length) writeJson(projectsPath(), kept);
+	return {
+		projects,
+		errors
+	};
+}
+// src/status.ts
+function inside(dir, root) {
+	return !!dir && (dir === root || dir.startsWith(root + sep));
+}
+async function serviceStatus(project, service, state) {
+	const base = {
+		project: project.name,
+		service: service.name,
+		port: service.port,
+		...service.port !== service.basePort ? { basePort: service.basePort } : {},
+		...project.worktree ? { worktree: project.worktree } : {},
+		url: `http://localhost:${service.port}`,
+		external: !service.command
+	};
+	const record = state.services[recordKey(project.instance, service.name)];
+	if (record) {
+		const alive = isAlive(record.supervisorPid) || isAlive(record.childPid);
+		const managed = {
+			pid: record.childPid ?? record.supervisorPid,
+			startedAt: record.startedAt,
+			log: record.log
+		};
+		if (record.root !== project.root && alive) return {
+			...base,
+			...managed,
+			state: "elsewhere",
+			root: record.root
+		};
+		if (record.exitedAt || !alive) return {
+			...base,
+			...managed,
+			state: "crashed",
+			exitCode: record.exitCode,
+			exitSignal: record.exitSignal
+		};
+		return {
+			...base,
+			...managed,
+			state: await isListening(service.port) ? "running" : "starting"
+		};
+	}
+	const log = service.command ? logPath(project.instance, service.name) : void 0;
+	if (!await isListening(service.port)) return {
+		...base,
+		log,
+		state: "stopped"
+	};
+	if (base.external) return {
+		...base,
+		state: "running"
+	};
+	const holder = await portHolder(service.port);
+	return {
+		...base,
+		log,
+		holder,
+		pid: holder?.pid,
+		state: inside(holder?.cwd, project.root) ? "unmanaged" : "taken"
+	};
+}
+async function projectStatus(project, state, only) {
+	return Promise.all((only ?? project.services).map((service) => serviceStatus(project, service, state)));
+}
+// src/worktrees.ts
+const OFFSET_STEP = 10;
+const MAX_TRIES = 100;
+/**
+* Gives a worktree of a `worktrees: true` project its port offset the first time portcall meets it:
+* the first multiple of 10 that moves its services onto ports no known project declares and nothing listens on.
+*/
+async function withPortOffset(project) {
+	if (!project.worktree || project.portOffset !== void 0) return project;
+	const claimed = new Set(knownProjects().projects.filter((p) => p.root !== project.root).flatMap((p) => p.services.map((s) => s.port)));
+	for (const service of project.services) claimed.add(service.basePort);
+	const runnable = project.services.filter((s) => s.command);
+	let chosen;
+	for (let i = 1; i <= MAX_TRIES && chosen === void 0; i++) {
+		const offset = i * OFFSET_STEP;
+		const ports = runnable.map((s) => s.basePort + offset);
+		if (ports.some((port) => port > 65535)) break;
+		if (ports.some((port) => claimed.has(port))) continue;
+		if (!(await Promise.all(ports.map((port) => isListening(port)))).some(Boolean)) chosen = offset;
+	}
+	if (chosen === void 0) throw new Error(`no free port offset for ${project.instance}: every candidate port is declared or in use`);
+	await updateState((state) => {
+		const offsets = state.offsets ??= {};
+		for (const root of Object.keys(offsets)) if (!existsSync(join(root, "portcall.json"))) delete offsets[root];
+		offsets[project.root] ??= chosen;
+	});
+	return loadProject(project.file, readState().offsets);
+}
+// src/commands.ts
+const SUPERVISE_COMMAND = "__supervise";
+const STOP_WAIT_MS = 8e3;
+var UsageError = class extends Error {};
+/** `name` is a project name, or `name@worktree` for a worktree with its own ports. */
+async function resolveProject(cwd, name) {
+	if (name) {
+		const { projects } = knownProjects();
+		const exact = projects.filter((project) => project.instance === name);
+		const matches = exact.length ? exact : projects.filter((project) => project.name === name);
+		if (matches.length === 0) throw new UsageError(`unknown project "${name}": run any portcall command once inside it so portcall knows where it is`);
+		const here = matches.find((project) => cwd === project.root || cwd.startsWith(`${project.root}/`));
+		if (here || matches.length === 1) return withPortOffset(here ?? matches[0]);
+		throw new UsageError(`"${name}" exists in several checkouts, run portcall from the one you want${matches.some((p) => p.worktree) ? " or name it as project@worktree" : ""}:\n${matches.map((p) => `  ${p.instance}  ${p.root}`).join("\n")}`);
+	}
+	const file = findConfig(cwd);
+	if (!file) throw new ConfigError(`no portcall.json in ${cwd} or above (see \`portcall help\`)`);
+	const project = await withPortOffset(loadProject(file, readState().offsets));
+	rememberProject(project.root);
+	return project;
+}
+function selectServices(project, names, runnableOnly = false) {
+	if (names.length === 0) return runnableOnly ? project.services.filter((s) => s.command) : project.services;
+	return names.map((name) => {
+		const service = project.services.find((s) => s.name === name);
+		if (!service) throw new UsageError(`${project.name} has no service "${name}" (services: ${project.services.map((s) => s.name).join(", ")})`);
+		if (runnableOnly && !service.command) throw new UsageError(`${project.name}/${name} is external (no command): portcall only checks its port`);
+		return service;
+	});
+}
+function worktreeFields(project) {
+	return project.worktree ? {
+		worktree: project.worktree,
+		portOffset: project.portOffset
+	} : {};
+}
+function table(rows) {
+	const widths = rows[0].map((_, i) => Math.max(...rows.map((row) => row[i].length)));
+	return rows.map((row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd()).join("\n");
+}
+function duration(ms) {
+	const s = Math.floor(ms / 1e3);
+	if (s < 60) return `${s}s`;
+	if (s < 3600) return `${Math.floor(s / 60)}m`;
+	if (s < 86400) return `${Math.floor(s / 3600)}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}`;
+	return `${Math.floor(s / 86400)}d`;
+}
+function short(text, max = 60) {
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function describe(status) {
+	switch (status.state) {
+		case "crashed": return status.exitSignal ? `killed by ${status.exitSignal}` : `exit code ${status.exitCode ?? "?"}`;
+		case "unmanaged": return `started outside portcall: ${short(status.holder?.command ?? "?")}`;
+		case "taken": return `port held by ${status.holder ? `${short(status.holder.command)} (${status.holder.cwd ?? "?"})` : "another process"}`;
+		case "elsewhere": return `run from ${status.root}`;
+		default: return status.external ? "external" : "";
+	}
+}
+function statusRows(statuses, withProject) {
+	const head = [
+		...withProject ? ["PROJECT"] : [],
+		"SERVICE",
+		"STATE",
+		"PORT",
+		"PID",
+		"UPTIME",
+		"INFO"
+	];
+	const now = Date.now();
+	return [head, ...statuses.map((s) => [
+		...withProject ? [s.worktree ? `${s.project}@${s.worktree}` : s.project] : [],
+		s.service,
+		s.state,
+		String(s.port),
+		s.pid ? String(s.pid) : "-",
+		s.startedAt && (s.state === "running" || s.state === "starting") ? duration(now - s.startedAt) : "-",
+		describe(s)
+	])];
+}
+async function status(io, cwd, opts) {
+	const state = readState();
+	if (opts.all) {
+		const { projects, errors } = knownProjects();
+		const statuses = (await Promise.all(projects.map((p) => projectStatus(p, state)))).flat();
+		if (io.json) io.out(JSON.stringify({
+			services: statuses,
+			errors
+		}, null, 2));
+		else {
+			io.out(statuses.length ? table(statusRows(statuses, true)) : "no known projects yet: run portcall once inside a project");
+			errors.forEach((e) => io.err(`portcall: ${e}`));
+		}
+		return 0;
+	}
+	const project = await resolveProject(cwd, opts.project);
+	const statuses = await projectStatus(project, state);
+	io.out(io.json ? JSON.stringify({
+		project: project.name,
+		...worktreeFields(project),
+		root: project.root,
+		services: statuses
+	}, null, 2) : table(statusRows(statuses, false)));
+	return 0;
+}
+const UP_FAILURES = [
+	"crashed",
+	"timeout",
+	"blocked"
+];
+function startService(project, service, state) {
+	const log = logPath(project.instance, service.name);
+	const spec = {
+		project: project.instance,
+		service: service.name,
+		command: service.command,
+		cwd: service.cwd,
+		env: {
+			PORT: String(service.port),
+			...service.env
+		},
+		log
+	};
+	const child = spawn(process.execPath, [
+		...process.execArgv,
+		process.argv[1],
+		SUPERVISE_COMMAND,
+		JSON.stringify(spec)
+	], {
+		cwd: service.cwd,
+		detached: true,
+		stdio: "ignore"
+	});
+	if (!child.pid) throw new Error(`could not start the supervisor for ${service.name}`);
+	let exited = false;
+	child.once("exit", () => {
+		exited = true;
+	});
+	child.unref();
+	state.services[recordKey(project.instance, service.name)] = {
+		project: project.instance,
+		service: service.name,
+		root: project.root,
+		port: service.port,
+		command: service.command,
+		supervisorPid: child.pid,
+		startedAt: Date.now(),
+		log
+	};
+	return {
+		pid: child.pid,
+		exited: () => exited
+	};
+}
+async function waitReady(service, exited) {
+	const deadline = Date.now() + service.readyTimeout * 1e3;
+	for (;;) {
+		if (exited()) return "exited";
+		if (await isListening(service.port, 300)) return "ready";
+		if (Date.now() > deadline) return "timeout";
+		await setTimeout$1(200);
+	}
+}
+async function up(io, cwd, names, opts) {
+	const project = await resolveProject(cwd, opts.project);
+	const services = selectServices(project, names);
+	const statuses = await projectStatus(project, readState(), services);
+	const results = [];
+	const toStart = [];
+	for (const [i, st] of statuses.entries()) {
+		const base = {
+			service: st.service,
+			port: st.port,
+			url: st.url
+		};
+		switch (st.state) {
+			case "running":
+			case "starting":
+				results.push({
+					...base,
+					outcome: st.external ? "external-up" : "already-running",
+					pid: st.pid
+				});
+				break;
+			case "unmanaged":
+				results.push({
+					...base,
+					outcome: "running-outside",
+					pid: st.pid,
+					detail: describe(st)
+				});
+				break;
+			case "elsewhere":
+			case "taken":
+				results.push({
+					...base,
+					outcome: "blocked",
+					pid: st.pid,
+					detail: describe(st)
+				});
+				break;
+			case "stopped":
+			case "crashed": if (st.external) results.push({
+				...base,
+				outcome: "external-down",
+				detail: "nothing listens on this port; portcall does not start external services"
+			});
+			else toStart.push(services[i]);
+		}
+	}
+	const started = await updateState((state) => toStart.map((service) => ({
+		service,
+		...startService(project, service, state)
+	})));
+	results.push(...await Promise.all(started.map(async ({ service, pid, exited }) => {
+		const base = {
+			service: service.name,
+			port: service.port,
+			url: `http://localhost:${service.port}`,
+			pid
+		};
+		if (!opts.wait) return {
+			...base,
+			outcome: "started",
+			detail: "not waiting for the port"
+		};
+		const t0 = Date.now();
+		const ready = await waitReady(service, exited);
+		if (ready === "ready") return {
+			...base,
+			outcome: "started",
+			detail: `ready in ${((Date.now() - t0) / 1e3).toFixed(1)}s`
+		};
+		const logTail = readLog(logPath(project.instance, service.name), service.name).slice(-30).map((l) => formatLine(l));
+		if (ready === "exited") {
+			const record = readState().services[recordKey(project.instance, service.name)];
+			return {
+				...base,
+				outcome: "crashed",
+				detail: `exited before listening (code ${record?.exitCode ?? "?"})`,
+				logTail
+			};
+		}
+		return {
+			...base,
+			outcome: "timeout",
+			detail: `still running but nothing listens on ${service.port} after ${service.readyTimeout}s (wrong port in portcall.json?)`,
+			logTail
+		};
+	})));
+	const order = new Map(services.map((s, i) => [s.name, i]));
+	results.sort((a, b) => order.get(a.service) - order.get(b.service));
+	const failed = results.some((r) => UP_FAILURES.includes(r.outcome));
+	if (io.json) io.out(JSON.stringify({
+		project: project.name,
+		...worktreeFields(project),
+		ok: !failed,
+		services: results
+	}, null, 2));
+	else {
+		io.out(table([[
+			"SERVICE",
+			"RESULT",
+			"URL",
+			"PID",
+			"INFO"
+		], ...results.map((r) => [
+			r.service,
+			r.outcome,
+			r.url,
+			r.pid ? String(r.pid) : "-",
+			r.detail ?? ""
+		])]));
+		for (const r of results.filter((r) => r.logTail?.length)) io.out(`\n--- ${r.service}: last log lines (portcall logs ${r.service}) ---\n${r.logTail.join("\n")}`);
+	}
+	return failed ? 1 : 0;
+}
+async function stopRecord(record) {
+	if (!record.exitedAt) {
+		signal(record.supervisorPid, "SIGTERM");
+		if (!await waitForDeath(record.supervisorPid, STOP_WAIT_MS)) signal(record.supervisorPid, "SIGKILL");
+		if (isAlive(record.childPid)) {
+			signalGroup(record.childPid, "SIGTERM");
+			if (!await waitForDeath(record.childPid, 3e3)) signalGroup(record.childPid, "SIGKILL");
+		}
+	}
+	await updateState((state) => {
+		const key = recordKey(record.project, record.service);
+		if (state.services[key]?.supervisorPid === record.supervisorPid) delete state.services[key];
+	});
+}
+async function stopPid(pid) {
+	signal(pid, "SIGTERM");
+	if (!await waitForDeath(pid, STOP_WAIT_MS)) signal(pid, "SIGKILL");
+}
+async function down(io, cwd, names, opts) {
+	const project = await resolveProject(cwd, opts.project);
+	const services = selectServices(project, names);
+	const state = readState();
+	const statuses = await projectStatus(project, state, services);
+	const results = await Promise.all(statuses.map(async (st) => {
+		const record = state.services[recordKey(project.instance, st.service)];
+		if (st.external) return {
+			service: st.service,
+			outcome: "skipped",
+			detail: "external, not managed by portcall"
+		};
+		switch (st.state) {
+			case "running":
+			case "starting":
+			case "crashed":
+				await stopRecord(record);
+				return {
+					service: st.service,
+					outcome: "stopped"
+				};
+			case "elsewhere":
+				if (!opts.force) return {
+					service: st.service,
+					outcome: "skipped",
+					detail: `${describe(st)}; --force to stop it from here`
+				};
+				await stopRecord(record);
+				return {
+					service: st.service,
+					outcome: "stopped",
+					detail: describe(st)
+				};
+			case "unmanaged":
+				if (!opts.force) return {
+					service: st.service,
+					outcome: "skipped",
+					detail: `${describe(st)} (pid ${st.pid}); --force to stop it`
+				};
+				await stopPid(st.pid);
+				return {
+					service: st.service,
+					outcome: "stopped",
+					detail: describe(st)
+				};
+			case "taken": return {
+				service: st.service,
+				outcome: "skipped",
+				detail: `${describe(st)}; not part of this project, portcall leaves it alone`
+			};
+			case "stopped": return {
+				service: st.service,
+				outcome: "not-running"
+			};
+		}
+	}));
+	if (!opts.quiet) {
+		if (io.json) io.out(JSON.stringify({
+			project: project.name,
+			services: results
+		}, null, 2));
+		else io.out(table([[
+			"SERVICE",
+			"RESULT",
+			"INFO"
+		], ...results.map((r) => [
+			r.service,
+			r.outcome,
+			r.detail ?? ""
+		])]));
+	}
+	return 0;
+}
+async function restart(io, cwd, names, opts) {
+	const runnable = selectServices(await resolveProject(cwd, opts.project), names, true).map((s) => s.name);
+	await down(io, cwd, runnable, {
+		...opts,
+		quiet: true
+	});
+	return up(io, cwd, runnable, opts);
+}
+async function logs(io, cwd, names, opts) {
+	const project = await resolveProject(cwd, opts.project);
+	const services = selectServices(project, names, true);
+	const files = services.map((s) => ({
+		file: logPath(project.instance, s.name),
+		service: s.name
+	}));
+	const width = services.length > 1 ? Math.max(...services.map((s) => s.name.length)) : 0;
+	const lines = filterLines(mergeLogs(files.map((f) => readLog(f.file, f.service))), opts.filter);
+	const toJson = (l) => ({
+		time: l.time?.toISOString(),
+		service: l.service,
+		stream: l.tag,
+		text: l.text
+	});
+	if (io.json && !opts.follow) io.out(JSON.stringify({
+		project: project.name,
+		lines: lines.map(toJson)
+	}, null, 2));
+	else if (lines.length) lines.forEach((l) => io.out(io.json ? JSON.stringify(toJson(l)) : formatLine(l, width)));
+	else if (!opts.follow) io.out(files.some((f) => readLog(f.file, f.service).length) ? "(no matching lines)" : "(no logs yet: start it with `portcall up`)");
+	if (opts.follow) await followLogs(files, (l) => io.out(io.json ? JSON.stringify(toJson(l)) : formatLine(l, width)), opts.filter);
+	return 0;
+}
+async function ports(io, cwd) {
+	if (findConfig(cwd)) await resolveProject(cwd);
+	const { projects, errors } = knownProjects();
+	const state = readState();
+	const claimant = (project, service) => service.command ? project.instance : project.name;
+	const claims = /* @__PURE__ */ new Map();
+	for (const project of projects) for (const service of project.services) claims.set(service.port, (claims.get(service.port) ?? /* @__PURE__ */ new Set()).add(claimant(project, service)));
+	const seen = /* @__PURE__ */ new Set();
+	const rows = [];
+	for (const project of projects) {
+		if (seen.has(project.instance)) continue;
+		seen.add(project.instance);
+		for (const [i, st] of (await projectStatus(project, state)).entries()) {
+			const own = claimant(project, project.services[i]);
+			const others = [...claims.get(st.port)].filter((name) => name !== own);
+			rows.push({
+				...st,
+				conflict: others
+			});
+		}
+	}
+	rows.sort((a, b) => a.port - b.port);
+	if (io.json) io.out(JSON.stringify({
+		ports: rows,
+		errors
+	}, null, 2));
+	else {
+		io.out(rows.length ? table([[
+			"PORT",
+			"PROJECT",
+			"SERVICE",
+			"STATE",
+			"INFO"
+		], ...rows.map((r) => [
+			String(r.port),
+			r.worktree ? `${r.project}@${r.worktree}` : r.project,
+			r.service,
+			r.state,
+			[r.conflict.length ? `CONFLICT with ${r.conflict.join(", ")}` : "", describe(r)].filter(Boolean).join("; ")
+		])]) : "no known projects yet: run portcall once inside a project");
+		errors.forEach((e) => io.err(`portcall: ${e}`));
+	}
+	return rows.some((r) => r.conflict.length) ? 1 : 0;
+}
+const AGENTS_SNIPPET = `## Dev servers
+
+Dev servers run under portcall (config: \`portcall.json\`). Never start them yourself (no \`pnpm dev\`, \`vite\`, \`tsx watch\`, \`node --watch\`...).
+
+- \`portcall status\`: what runs, on which port. Check it before assuming a server is down.
+- \`portcall up [service]\`: start what is not running; a no-op for what already is. It waits for the port and prints the log tail if the server crashes.
+- \`portcall restart <service>\`: after changing env, config or dependencies (watch mode reloads code by itself).
+- \`portcall logs <service> --errors\`, \`--since 2m\`, \`--grep <regex>\`, \`-n 200\`: server output, e.g. after a failing request.
+- Leave servers running when you are done. Add \`--json\` to any command for machine-readable output.
+`;
+function agents(io) {
+	io.out(AGENTS_SNIPPET.trimEnd());
+	return 0;
+}
+// src/supervise.ts
+const KILL_AFTER_MS = 5e3;
+const CLOSE_GRACE_MS = 3e3;
+const ANSI = /\x1B(?:\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]|\][^\x07]*(?:\x07|\x1B\\)|[\x40-\x5A\x5C-\x5F])/g;
+/** Plain text for the log: no escape codes, and a progress bar (`\r` rewrites) kept at its last state. */
+function cleanLine(line) {
+	const text = line.replace(ANSI, "");
+	return text.slice(text.lastIndexOf("\r") + 1).trimEnd();
+}
+/**
+* Runs in its own detached process, one per service: starts the command in a
+* new process group, timestamps its output into the log, records how it ended.
+*/
+function supervise(spec) {
+	const key = recordKey(spec.project, spec.service);
+	mkdirSync(dirname(spec.log), { recursive: true });
+	if (existsSync(spec.log)) renameSync(spec.log, `${spec.log}.1`);
+	const out = createWriteStream(spec.log, { flags: "a" });
+	const write = (tag, text) => {
+		out.write(`${(/* @__PURE__ */ new Date()).toISOString()} [${tag}] ${text}\n`);
+	};
+	write("portcall", `$ ${spec.command}`);
+	const child = spawn("/bin/sh", ["-c", spec.command], {
+		cwd: spec.cwd,
+		env: {
+			...process.env,
+			...spec.env
+		},
+		detached: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	for (const [stream, tag] of [[child.stdout, "out"], [child.stderr, "err"]]) createInterface({
+		input: stream,
+		crlfDelay: 1e400
+	}).on("line", (line) => {
+		const text = cleanLine(line);
+		if (text) write(tag, text);
+	});
+	updateState((state) => {
+		const record = state.services[key];
+		if (record?.supervisorPid === process.pid) record.childPid = child.pid;
+	});
+	let stopping = false;
+	const stop = () => {
+		if (stopping) return;
+		stopping = true;
+		write("portcall", "stopping");
+		signalGroup(child.pid, "SIGTERM");
+		setTimeout(signalGroup, KILL_AFTER_MS, child.pid, "SIGKILL").unref();
+	};
+	process.on("SIGTERM", stop);
+	process.on("SIGINT", stop);
+	process.on("SIGHUP", () => {});
+	let finished = false;
+	const finish = async (code, sig) => {
+		if (finished) return;
+		finished = true;
+		write("portcall", stopping ? "stopped" : `exited with ${sig ? `signal ${sig}` : `code ${code}`}`);
+		try {
+			await updateState((state) => {
+				const record = state.services[key];
+				if (record?.supervisorPid !== process.pid) return;
+				if (stopping) delete state.services[key];
+				else Object.assign(record, {
+					exitCode: code,
+					exitSignal: sig,
+					exitedAt: Date.now()
+				});
+			});
+		} finally {
+			out.end(() => process.exit(0));
+		}
+	};
+	child.on("error", (error) => {
+		write("portcall", `failed to start: ${error.message}`);
+		finish(127, null);
+	});
+	child.on("exit", (code, sig) => {
+		signalGroup(child.pid, "SIGTERM");
+		setTimeout(() => void finish(code, sig), CLOSE_GRACE_MS).unref();
+		child.on("close", () => void finish(code, sig));
+	});
+}
+// src/cli.ts
+const USAGE = `portcall - run your dev servers in the background, on fixed ports, with logs agents can read
+
+Usage:
+  portcall up [service...]        Start services (no-op for the ones already running), wait for their port
+  portcall down [service...]      Stop services
+  portcall restart [service...]   Stop then start
+  portcall status [--all]         What runs, on which port (--all: every project portcall knows)
+  portcall logs [service...]      Service output (all services when none named)
+  portcall ports                  Every known project's ports, with conflicts
+  portcall agents                 Print an AGENTS.md section telling coding agents how to use portcall
+
+Options:
+  -p, --project <name>  Act on a known project from anywhere (default: the portcall.json at or above the cwd);
+                        <name>@<worktree> for a git worktree with its own ports
+  -C, --cwd <dir>       Run as if started in <dir>
+      --json            Machine-readable output
+      --no-wait         up/restart: return without waiting for the port
+      --force           down/restart: also stop a server of this project started outside portcall
+  -h, --help            This help
+  -v, --version         Print the version
+
+Logs:
+  -n, --lines <n>       Last n lines (default 100)
+      --since <time>    Only lines after 30s, 5m, 2h, 1d or a date
+      --grep <regex>    Only lines matching (case-insensitive)
+      --errors          Only error lines, with their stack traces
+  -f, --follow          Keep printing new lines
+
+portcall.json, at the project root:
+  {
+    "name": "myapp",
+    "services": {
+      "server": { "command": "pnpm dev:server", "port": 3000 },
+      "web": { "command": "pnpm dev:web", "port": 5173, "env": { "API_URL": "http://localhost:{ports.server}" } },
+      "db": { "port": 5432 }
+    }
+  }
+  A service without "command" is external (a database in Docker...): portcall only checks its port.
+  Each command gets PORT set to its port. Logs and state live in ~/.portcall (PORTCALL_HOME).
+  "worktrees": true gives each git worktree its own ports (declared + an offset), so they run at once.
+`;
+async function main(argv) {
+	if (argv[0] === "__supervise") {
+		supervise(JSON.parse(argv[1]));
+		return -1;
+	}
+	const { values, positionals } = parseArgs({
+		args: argv,
+		allowPositionals: true,
+		options: {
+			"project": {
+				type: "string",
+				short: "p"
+			},
+			"cwd": {
+				type: "string",
+				short: "C"
+			},
+			"json": { type: "boolean" },
+			"all": {
+				type: "boolean",
+				short: "a"
+			},
+			"no-wait": { type: "boolean" },
+			"force": { type: "boolean" },
+			"lines": {
+				type: "string",
+				short: "n"
+			},
+			"since": { type: "string" },
+			"grep": { type: "string" },
+			"errors": { type: "boolean" },
+			"follow": {
+				type: "boolean",
+				short: "f"
+			},
+			"help": {
+				type: "boolean",
+				short: "h"
+			},
+			"version": {
+				type: "boolean",
+				short: "v"
+			}
+		}
+	});
+	const io = {
+		json: !!values.json,
+		out: (text) => process.stdout.write(`${text}\n`),
+		err: (text) => process.stderr.write(`${text}\n`)
+	};
+	if (values.version) {
+		io.out(version$1);
+		return 0;
+	}
+	const [command = "help", ...names] = positionals;
+	if (values.help || command === "help") {
+		io.out(USAGE.trimEnd());
+		return 0;
+	}
+	const cwd = resolve(values.cwd ?? process.cwd());
+	const project = values.project;
+	const wait = !values["no-wait"];
+	switch (command) {
+		case "up":
+		case "start": return up(io, cwd, names, {
+			project,
+			wait
+		});
+		case "down":
+		case "stop": return down(io, cwd, names, {
+			project,
+			force: values.force
+		});
+		case "restart": return restart(io, cwd, names, {
+			project,
+			force: values.force,
+			wait
+		});
+		case "status":
+		case "ps": return status(io, cwd, {
+			project,
+			all: values.all
+		});
+		case "logs": {
+			const lines = values.lines === void 0 ? 100 : Number(values.lines);
+			if (!Number.isInteger(lines) || lines < 1) throw new Error(`--lines: expected a positive number, got "${values.lines}"`);
+			let grep;
+			try {
+				grep = values.grep === void 0 ? void 0 : new RegExp(values.grep, "i");
+			} catch {
+				throw new Error(`--grep: invalid regular expression "${values.grep}"`);
+			}
+			return logs(io, cwd, names, {
+				project,
+				follow: values.follow,
+				filter: {
+					limit: lines,
+					since: values.since === void 0 ? void 0 : parseSince(values.since),
+					grep,
+					errors: values.errors
+				}
+			});
+		}
+		case "ports": return ports(io, cwd);
+		case "agents": return agents(io);
+		default: throw new Error(`unknown command "${command}" (see \`portcall help\`)`);
+	}
+}
+main(process.argv.slice(2)).then((code) => {
+	if (code >= 0) process.exitCode = code;
+}, (error) => {
+	if (process.argv.includes("--json")) process.stdout.write(`${JSON.stringify({ error: error.message })}\n`);
+	else process.stderr.write(`portcall: ${error.message}\n`);
+	process.exitCode = 1;
+});
+export {};