@keystrokehq/cli 0.0.137 → 0.0.139

package/dist/{discovery-XqwkB9H_-C2XdYbG2.mjs → discovery-DV7FkTRA-BFmtZG9u.mjs}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { relative, sep } from "node:path";
+import { join, relative, sep } from "node:path";
+import { readdir, stat } from "node:fs/promises";
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
 var _a$1;
 function $constructor(name, initializer, params) {
@@ -449,6 +450,7 @@ const _parse = (_Err) => (schema, value, _ctx, _params) => {
 	}
 	return result.value;
 };
+const parse$1 = /* @__PURE__ */ _parse($ZodRealError);
 const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
 	const ctx = _ctx ? {
 		..._ctx,
@@ -466,6 +468,7 @@ const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
 	}
 	return result.value;
 };
+const parseAsync$1 = /* @__PURE__ */ _parseAsync($ZodRealError);
 const _safeParse = (_Err) => (schema, value, _ctx) => {
 	const ctx = _ctx ? {
 		..._ctx,
@@ -1917,6 +1920,98 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
+const $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
+	$ZodType.init(inst, def);
+	const items = def.items;
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!Array.isArray(input)) {
+			payload.issues.push({
+				input,
+				inst,
+				expected: "tuple",
+				code: "invalid_type"
+			});
+			return payload;
+		}
+		payload.value = [];
+		const proms = [];
+		const optinStart = getTupleOptStart(items, "optin");
+		const optoutStart = getTupleOptStart(items, "optout");
+		if (!def.rest) {
+			if (input.length < optinStart) {
+				payload.issues.push({
+					code: "too_small",
+					minimum: optinStart,
+					inclusive: true,
+					input,
+					inst,
+					origin: "array"
+				});
+				return payload;
+			}
+			if (input.length > items.length) payload.issues.push({
+				code: "too_big",
+				maximum: items.length,
+				inclusive: true,
+				input,
+				inst,
+				origin: "array"
+			});
+		}
+		const itemResults = new Array(items.length);
+		for (let i = 0; i < items.length; i++) {
+			const r = items[i]._zod.run({
+				value: input[i],
+				issues: []
+			}, ctx);
+			if (r instanceof Promise) proms.push(r.then((rr) => {
+				itemResults[i] = rr;
+			}));
+			else itemResults[i] = r;
+		}
+		if (def.rest) {
+			let i = items.length - 1;
+			const rest = input.slice(items.length);
+			for (const el of rest) {
+				i++;
+				const result = def.rest._zod.run({
+					value: el,
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((r) => handleTupleResult(r, payload, i)));
+				else handleTupleResult(result, payload, i);
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
+		return handleTupleResults(itemResults, payload, items, input, optoutStart);
+	};
+});
+function getTupleOptStart(items, key) {
+	for (let i = items.length - 1; i >= 0; i--) if (items[i]._zod[key] !== "optional") return i + 1;
+	return 0;
+}
+function handleTupleResult(result, final, index) {
+	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
+	final.value[index] = result.value;
+}
+function handleTupleResults(itemResults, final, items, input, optoutStart) {
+	for (let i = 0; i < items.length; i++) {
+		const r = itemResults[i];
+		const isPresent = i < input.length;
+		if (r.issues.length) {
+			if (!isPresent && i >= optoutStart) {
+				final.value.length = i;
+				break;
+			}
+			final.issues.push(...prefixIssues(i, r.issues));
+		}
+		final.value[i] = r.value;
+	}
+	for (let i = final.value.length - 1; i >= input.length; i--) if (items[i]._zod.optout === "optional" && final.value[i] === void 0) final.value.length = i;
+	else break;
+	return final;
+}
 const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -2264,6 +2359,69 @@ function handleReadonlyResult(payload) {
 	payload.value = Object.freeze(payload.value);
 	return payload;
 }
+const $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._def = def;
+	inst._zod.def = def;
+	inst.implement = (func) => {
+		if (typeof func !== "function") throw new Error("implement() must be called with a function");
+		return function(...args) {
+			const parsedArgs = inst._def.input ? parse$1(inst._def.input, args) : args;
+			const result = Reflect.apply(func, this, parsedArgs);
+			if (inst._def.output) return parse$1(inst._def.output, result);
+			return result;
+		};
+	};
+	inst.implementAsync = (func) => {
+		if (typeof func !== "function") throw new Error("implementAsync() must be called with a function");
+		return async function(...args) {
+			const parsedArgs = inst._def.input ? await parseAsync$1(inst._def.input, args) : args;
+			const result = await Reflect.apply(func, this, parsedArgs);
+			if (inst._def.output) return await parseAsync$1(inst._def.output, result);
+			return result;
+		};
+	};
+	inst._zod.parse = (payload, _ctx) => {
+		if (typeof payload.value !== "function") {
+			payload.issues.push({
+				code: "invalid_type",
+				expected: "function",
+				input: payload.value,
+				inst
+			});
+			return payload;
+		}
+		if (inst._def.output && inst._def.output._zod.def.type === "promise") payload.value = inst.implementAsync(payload.value);
+		else payload.value = inst.implement(payload.value);
+		return payload;
+	};
+	inst.input = (...args) => {
+		const F = inst.constructor;
+		if (Array.isArray(args[0])) return new F({
+			type: "function",
+			input: new $ZodTuple({
+				type: "tuple",
+				items: args[0],
+				rest: args[1]
+			}),
+			output: inst._def.output
+		});
+		return new F({
+			type: "function",
+			input: args[0],
+			output: inst._def.output
+		});
+	};
+	inst.output = (output) => {
+		const F = inst.constructor;
+		return new F({
+			type: "function",
+			input: inst._def.input,
+			output
+		});
+	};
+	return inst;
+});
 const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
 	$ZodCheck.init(inst, def);
 	$ZodType.init(inst, def);
@@ -3208,9 +3366,33 @@ const numberProcessor = (schema, ctx, _json, _params) => {
 const booleanProcessor = (_schema, _ctx, json, _params) => {
 	json.type = "boolean";
 };
+const bigintProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("BigInt cannot be represented in JSON Schema");
+};
+const symbolProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Symbols cannot be represented in JSON Schema");
+};
+const nullProcessor = (_schema, ctx, json, _params) => {
+	if (ctx.target === "openapi-3.0") {
+		json.type = "string";
+		json.nullable = true;
+		json.enum = [null];
+	} else json.type = "null";
+};
+const undefinedProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Undefined cannot be represented in JSON Schema");
+};
+const voidProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Void cannot be represented in JSON Schema");
+};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
+const anyProcessor = (_schema, _ctx, _json, _params) => {};
+const unknownProcessor = (_schema, _ctx, _json, _params) => {};
+const dateProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Date cannot be represented in JSON Schema");
+};
 const enumProcessor = (schema, _ctx, json, _params) => {
 	const def = schema._zod.def;
 	const values = getEnumValues(def.entries);
@@ -3239,12 +3421,53 @@ const literalProcessor = (schema, ctx, json, _params) => {
 		json.enum = vals;
 	}
 };
+const nanProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("NaN cannot be represented in JSON Schema");
+};
+const templateLiteralProcessor = (schema, _ctx, json, _params) => {
+	const _json = json;
+	const pattern = schema._zod.pattern;
+	if (!pattern) throw new Error("Pattern not found in template literal");
+	_json.type = "string";
+	_json.pattern = pattern.source;
+};
+const fileProcessor = (schema, _ctx, json, _params) => {
+	const _json = json;
+	const file = {
+		type: "string",
+		format: "binary",
+		contentEncoding: "binary"
+	};
+	const { minimum, maximum, mime } = schema._zod.bag;
+	if (minimum !== void 0) file.minLength = minimum;
+	if (maximum !== void 0) file.maxLength = maximum;
+	if (mime) if (mime.length === 1) {
+		file.contentMediaType = mime[0];
+		Object.assign(_json, file);
+	} else {
+		Object.assign(_json, file);
+		_json.anyOf = mime.map((m) => ({ contentMediaType: m }));
+	}
+	else Object.assign(_json, file);
+};
+const successProcessor = (_schema, _ctx, json, _params) => {
+	json.type = "boolean";
+};
 const customProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
 };
+const functionProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Function types cannot be represented in JSON Schema");
+};
 const transformProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Transforms cannot be represented in JSON Schema");
 };
+const mapProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Map cannot be represented in JSON Schema");
+};
+const setProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Set cannot be represented in JSON Schema");
+};
 const arrayProcessor = (schema, ctx, _json, params) => {
 	const json = _json;
 	const def = schema._zod.def;
@@ -3321,6 +3544,44 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
 	json.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
 };
+const tupleProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "array";
+	const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
+	const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
+	const prefixItems = def.items.map((x, i) => process(x, ctx, {
+		...params,
+		path: [
+			...params.path,
+			prefixPath,
+			i
+		]
+	}));
+	const rest = def.rest ? process(def.rest, ctx, {
+		...params,
+		path: [
+			...params.path,
+			restPath,
+			...ctx.target === "openapi-3.0" ? [def.items.length] : []
+		]
+	}) : null;
+	if (ctx.target === "draft-2020-12") {
+		json.prefixItems = prefixItems;
+		if (rest) json.items = rest;
+	} else if (ctx.target === "openapi-3.0") {
+		json.items = { anyOf: prefixItems };
+		if (rest) json.items.anyOf.push(rest);
+		json.minItems = prefixItems.length;
+		if (!rest) json.maxItems = prefixItems.length;
+	} else {
+		json.items = prefixItems;
+		if (rest) json.additionalItems = rest;
+	}
+	const { minimum, maximum } = schema._zod.bag;
+	if (typeof minimum === "number") json.minItems = minimum;
+	if (typeof maximum === "number") json.maxItems = maximum;
+};
 const recordProcessor = (schema, ctx, _json, params) => {
 	const json = _json;
 	const def = schema._zod.def;
@@ -3411,12 +3672,99 @@ const readonlyProcessor = (schema, ctx, json, params) => {
 	seen.ref = def.innerType;
 	json.readOnly = true;
 };
+const promiseProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+};
 const optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
 	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
+const lazyProcessor = (schema, ctx, _json, params) => {
+	const innerType = schema._zod.innerType;
+	process(innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = innerType;
+};
+const allProcessors = {
+	string: stringProcessor,
+	number: numberProcessor,
+	boolean: booleanProcessor,
+	bigint: bigintProcessor,
+	symbol: symbolProcessor,
+	null: nullProcessor,
+	undefined: undefinedProcessor,
+	void: voidProcessor,
+	never: neverProcessor,
+	any: anyProcessor,
+	unknown: unknownProcessor,
+	date: dateProcessor,
+	enum: enumProcessor,
+	literal: literalProcessor,
+	nan: nanProcessor,
+	template_literal: templateLiteralProcessor,
+	file: fileProcessor,
+	success: successProcessor,
+	custom: customProcessor,
+	function: functionProcessor,
+	transform: transformProcessor,
+	map: mapProcessor,
+	set: setProcessor,
+	array: arrayProcessor,
+	object: objectProcessor,
+	union: unionProcessor,
+	intersection: intersectionProcessor,
+	tuple: tupleProcessor,
+	record: recordProcessor,
+	nullable: nullableProcessor,
+	nonoptional: nonoptionalProcessor,
+	default: defaultProcessor,
+	prefault: prefaultProcessor,
+	catch: catchProcessor,
+	pipe: pipeProcessor,
+	readonly: readonlyProcessor,
+	promise: promiseProcessor,
+	optional: optionalProcessor,
+	lazy: lazyProcessor
+};
+function toJSONSchema(input, params) {
+	if ("_idmap" in input) {
+		const registry = input;
+		const ctx = initializeContext({
+			...params,
+			processors: allProcessors
+		});
+		const defs = {};
+		for (const entry of registry._idmap.entries()) {
+			const [_, schema] = entry;
+			process(schema, ctx);
+		}
+		const schemas = {};
+		ctx.external = {
+			registry,
+			uri: params?.uri,
+			defs
+		};
+		for (const entry of registry._idmap.entries()) {
+			const [key, schema] = entry;
+			extractDefs(ctx, schema);
+			schemas[key] = finalize(ctx, schema);
+		}
+		if (Object.keys(defs).length > 0) schemas.__shared = { [ctx.target === "draft-2020-12" ? "$defs" : "definitions"]: defs };
+		return { schemas };
+	}
+	const ctx = initializeContext({
+		...params,
+		processors: allProcessors
+	});
+	process(input, ctx);
+	extractDefs(ctx, input);
+	return finalize(ctx, input);
+}
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/iso.js
 const ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
@@ -4051,6 +4399,24 @@ function intersection(left, right) {
 		right
 	});
 }
+const ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
+	$ZodTuple.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => tupleProcessor(inst, ctx, json, params);
+	inst.rest = (rest) => inst.clone({
+		...inst._zod.def,
+		rest
+	});
+});
+function tuple(items, _paramsOrRest, _params) {
+	const hasRest = _paramsOrRest instanceof $ZodType;
+	return new ZodTuple({
+		type: "tuple",
+		items,
+		rest: hasRest ? _paramsOrRest : null,
+		...normalizeParams(hasRest ? _params : _paramsOrRest)
+	});
+}
 const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
 	$ZodRecord.init(inst, def);
 	ZodType.init(inst, def);
@@ -4280,6 +4646,18 @@ function readonly(innerType) {
 		innerType
 	});
 }
+const ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
+	$ZodFunction.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => functionProcessor(inst, ctx, json, params);
+});
+function _function(params) {
+	return new ZodFunction({
+		type: "function",
+		input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
+		output: params?.output ?? unknown()
+	});
+}
 const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
 	$ZodCustom.init(inst, def);
 	ZodType.init(inst, def);
@@ -4295,11 +4673,11 @@ function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
 //#endregion
-//#region ../../packages/server/dist/discovery-XqwkB9H_.mjs
+//#region ../../packages/manifest/dist/discovery-DV7FkTRA.mjs
 const SOURCE_EXT = /\.(ts|mts|mjs|js)$/;
-const DECLARATION_FILE = /\.d\.(ts|mts|cts)$/;
+const DECLARATION_FILE$1 = /\.d\.(ts|mts|cts)$/;
 function entryIdFromFile(rootDir, filePath, options) {
-	if (DECLARATION_FILE.test(filePath)) return null;
+	if (DECLARATION_FILE$1.test(filePath)) return null;
 	const baseName = filePath.split(sep).at(-1) ?? "";
 	if (/\.(int\.)?test\.(ts|mts)$/.test(baseName)) return null;
 	const segments = relative(rootDir, filePath).replace(SOURCE_EXT, "").split(sep).filter((segment) => segment.length > 0);
@@ -4311,7 +4689,55 @@ function entryIdFromFile(rootDir, filePath, options) {
 	const id = segments.slice(0, -1).join("/");
 	return id.length > 0 ? id : null;
 }
+const SOURCE_FILE = /\.(ts|mts|mjs|js)$/;
+const TEST_FILE = /\.(int\.)?test\.(ts|mts)$/;
+const DECLARATION_FILE = /\.d\.(ts|mts|cts)$/;
+const JUNK_FILE = /^\._|\.DS_Store$/;
+async function walkTypeScriptFiles(dir) {
+	let names;
+	try {
+		names = await readdir(dir);
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	const files = [];
+	for (const name of names) {
+		const path = join(dir, name);
+		if ((await stat(path)).isDirectory()) files.push(...await walkTypeScriptFiles(path));
+		else if (!JUNK_FILE.test(name) && SOURCE_FILE.test(name) && !DECLARATION_FILE.test(name) && !TEST_FILE.test(name)) files.push(path);
+	}
+	return files;
+}
+async function discoverEntries(rootDir, options) {
+	const files = await walkTypeScriptFiles(rootDir);
+	const byKey = /* @__PURE__ */ new Map();
+	for (const filePath of files) {
+		const id = entryIdFromFile(rootDir, filePath, options);
+		if (!id) continue;
+		const key = options.formatKey(id);
+		const moduleFile = relative(rootDir, filePath);
+		const existing = byKey.get(key);
+		if (existing) throw new Error(`Duplicate ${options.duplicateLabel} ${key}: ${existing.filePath} and ${filePath}`);
+		byKey.set(key, {
+			key,
+			filePath,
+			moduleFile
+		});
+	}
+	return [...byKey.values()];
+}
+async function discoverModuleFileEntries(rootDir, options) {
+	return (await discoverEntries(rootDir, {
+		nestedEntry: options.nestedEntry,
+		formatKey: (id) => id,
+		duplicateLabel: options.duplicateLabel
+	})).filter((entry) => options.shouldDiscoverFile?.(entry.filePath) ?? true).map(({ filePath, moduleFile }) => ({
+		filePath,
+		moduleFile
+	}));
+}
 //#endregion
-export { _coercedNumber as _, array as a, discriminatedUnion as c, object as d, record as f, url as g, unknown as h, _enum as i, literal as l, union as m, ZodNumber as n, boolean as o, string as p, ZodType as r, custom as s, entryIdFromFile as t, number as u };
+export { _coercedNumber as S, string as _, ZodNumber as a, url as b, _function as c, custom as d, discriminatedUnion as f, record as g, object as h, walkTypeScriptFiles as i, array as l, number as m, discoverModuleFileEntries as n, ZodType as o, literal as p, entryIdFromFile as r, _enum as s, discoverEntries as t, boolean as u, union as v, toJSONSchema as x, unknown as y };
 
-//# sourceMappingURL=discovery-XqwkB9H_-C2XdYbG2.mjs.map
+//# sourceMappingURL=discovery-DV7FkTRA-BFmtZG9u.mjs.map