@cerios/salesforce-sobjectly 0.0.0-stage → 1.0.0

package/dist/codegen-BgDgU2RR.cjs

@@ -0,0 +1,1209 @@
+const require_sf_cli = require("./sf-cli-DEVZQTR7.cjs");
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let jiti = require("jiti");
+let node_readline = require("node:readline");
+//#region src/codegen/type-mapper.ts
+const ADDRESS_TYPE = "SalesforceAddress";
+const GEOLOCATION_TYPE = "SalesforceGeolocation";
+/** Maps each Salesforce field type to a TypeScript type. Types not listed become `unknown`. */
+const FIELD_TYPE_MAP = {
+	boolean: "boolean",
+	int: "number",
+	long: "number",
+	double: "number",
+	currency: "number",
+	percent: "number",
+	/** ISO date, `yyyy-MM-dd`. */
+	date: "string",
+	/** ISO date-time, e.g. `2026-01-31T12:00:00.000+0000`. */
+	datetime: "string",
+	/** `HH:mm:ss.SSSZ`. */
+	time: "string",
+	id: "string",
+	reference: "string",
+	string: "string",
+	textarea: "string",
+	picklist: "string",
+	/** Values separated by `;`. */
+	multipicklist: "string",
+	combobox: "string",
+	email: "string",
+	phone: "string",
+	url: "string",
+	encryptedstring: "string",
+	/** Base64-encoded content. */
+	base64: "string",
+	address: ADDRESS_TYPE,
+	location: GEOLOCATION_TYPE
+};
+/** Returns the TypeScript type for a field, including `| null` for nillable fields. */
+function mapFieldType(field, picklists = "union") {
+	const base = picklistType(field, picklists) ?? FIELD_TYPE_MAP[field.type] ?? "unknown";
+	return field.nillable && base !== "unknown" ? `${base} | null` : base;
+}
+function picklistType(field, picklists) {
+	if (picklists !== "union" || field.type !== "picklist" && field.type !== "combobox") return;
+	const values = [...new Set((field.picklistValues ?? []).filter((entry) => entry.active).map((entry) => entry.value))];
+	if (values.length === 0) return;
+	const union = values.map((value) => JSON.stringify(value)).join(" | ");
+	return field.restrictedPicklist && field.type === "picklist" ? union : `${union} | (string & {})`;
+}
+//#endregion
+//#region src/codegen/generator.ts
+/** Field types whose kind is recorded in the registry's `fieldKinds`. */
+const FIELD_KINDS = /* @__PURE__ */ new Set([
+	"date",
+	"datetime",
+	"time",
+	"multipicklist"
+]);
+const IDENTIFIER$1 = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* Generates the TypeScript source for a set of sObject describes: a read interface, create
+* and update input types per sObject, and the `SObjectRegistry` that ties them together.
+* The output is deterministic: sObjects are sorted by name and fields by name (`Id` first).
+*/
+function generateSource(describes, options = {}) {
+	const sorted = [...describes].sort((a, b) => compare(a.name, b.name));
+	assertGeneratableNames(sorted);
+	const names = new Set(sorted.map((describe) => describe.name));
+	const sections = [imports(sorted, options.importSource ?? "@cerios/salesforce-sobjectly")];
+	const objectHashes = [];
+	for (const describe of sorted) {
+		const objectSections = [
+			readInterface(describe, options.picklists ?? "union"),
+			inputType(describe, "CreateInput", "createable", lookup(options.excludeCreateFields, describe.name)),
+			inputType(describe, "UpdateInput", "updateable", lookup(options.excludeUpdateFields, describe.name))
+		];
+		sections.push(...objectSections);
+		const fingerprint = [
+			...objectSections,
+			registryEntry(describe, names),
+			options.constants === false ? "" : picklistEntry(describe)
+		].join("\n");
+		objectHashes.push(`${describe.name}:${sha256(fingerprint).slice(0, OBJECT_HASH_LENGTH)}`);
+	}
+	sections.push(registry(sorted, names));
+	if (options.constants !== false) sections.push(picklistConstants(sorted), recordTypeConstants(sorted));
+	if (options.apiVersion) sections.push(apiVersionConstant(options.apiVersion));
+	const body = sections.filter((section) => section.length > 0).join("\n\n");
+	return `${header(sha256(body), objectHashes)}\n\n${body}\n`;
+}
+/** Names the generated file uses itself; an sObject with one of these names would break it. */
+const RESERVED_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"Record",
+	"Pick",
+	"Partial",
+	"SObjectRegistry",
+	"PICKLIST_VALUES",
+	"RECORD_TYPES",
+	"API_VERSION",
+	ADDRESS_TYPE,
+	GEOLOCATION_TYPE
+]);
+/** Fails with a clear message for sObject names the generated TypeScript can't represent. */
+function assertGeneratableNames(describes) {
+	const seen = /* @__PURE__ */ new Map();
+	const generated = new Set(describes.flatMap((describe) => [`${describe.name}CreateInput`, `${describe.name}UpdateInput`]));
+	for (const { name } of describes) {
+		if (!IDENTIFIER$1.test(name)) throw new Error(`sObject name "${name}" is not a valid TypeScript identifier.`);
+		if (RESERVED_TYPE_NAMES.has(name) || generated.has(name)) throw new Error(`sObject name "${name}" clashes with a type the generated file defines; exclude it.`);
+		const previous = seen.get(name.toLowerCase());
+		if (previous !== void 0) throw new Error(`sObjects "${previous}" and "${name}" differ only in case; list each sObject once.`);
+		seen.set(name.toLowerCase(), name);
+	}
+}
+/** Looks up a per-sObject option case-insensitively (sObject names are case-insensitive in Salesforce). */
+function lookup(map, name) {
+	if (!map) return [];
+	const key = Object.keys(map).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+	return key === void 0 ? [] : map[key] ?? [];
+}
+const CONTENT_HASH_PREFIX = "// sobjectly-content-hash: sha256:";
+const OBJECT_HASHES_PREFIX = "// sobjectly-sobjects: ";
+const OBJECT_HASH_LENGTH = 12;
+function header(contentHash, objectHashes) {
+	return [
+		"// ──────────────────────────────────────────────────────────────",
+		"// AUTO-GENERATED by @cerios/salesforce-sobjectly (`sobjectly generate`).",
+		"// Do not edit manually; re-run the generator instead.",
+		"// ──────────────────────────────────────────────────────────────",
+		`${CONTENT_HASH_PREFIX}${contentHash}`,
+		`${OBJECT_HASHES_PREFIX}${objectHashes.join(",")}`,
+		"/* eslint-disable */"
+	].join("\n");
+}
+/** Reads the content hashes from a generated file's header (also after reformatting). */
+function readGeneratedHashes(source) {
+	const lines = source.split(/\r?\n/).map((line) => line.trim());
+	const hashLine = lines.find((line) => line.startsWith(CONTENT_HASH_PREFIX));
+	if (!hashLine) return;
+	const objectsLine = lines.find((line) => line.startsWith(OBJECT_HASHES_PREFIX)) ?? OBJECT_HASHES_PREFIX;
+	const sobjects = /* @__PURE__ */ new Map();
+	for (const entry of objectsLine.slice(23).split(",")) {
+		const [name, hash] = entry.split(":");
+		if (name && hash) sobjects.set(name, hash);
+	}
+	return {
+		contentHash: hashLine.slice(34),
+		sobjects
+	};
+}
+function sha256(text) {
+	return (0, node_crypto.createHash)("sha256").update(text).digest("hex");
+}
+function imports(describes, importSource) {
+	const used = [];
+	const fields = describes.flatMap((describe) => describe.fields);
+	if (fields.some((field) => field.type === "address")) used.push(ADDRESS_TYPE);
+	if (fields.some((field) => field.type === "location")) used.push(GEOLOCATION_TYPE);
+	return used.length > 0 ? `import type { ${used.join(", ")} } from ${JSON.stringify(importSource)};` : "";
+}
+function sortedFields(describe) {
+	return [...describe.fields].sort((a, b) => a.name === "Id" ? -1 : b.name === "Id" ? 1 : compare(a.name, b.name));
+}
+function readInterface(describe, picklists) {
+	const lines = sortedFields(describe).map((field) => {
+		return `${`\t/** ${escapeComment(field.label)} (${escapeComment(field.type)}) */`}\n\t${propertyKey(field.name)}: ${mapFieldType(field, picklists)};`;
+	});
+	return `${describe.label ? `/** ${escapeComment(describe.label)} */\n` : ""}export interface ${describe.name} {\n${lines.join("\n")}\n}`;
+}
+/**
+* Create input: required fields are `createable && !nillable && !defaultedOnCreate`; other
+* createable fields are optional. Validation rules and record types can add more requirements
+* at runtime. Update input: every updateable field is optional.
+*/
+function inputType(describe, suffix, flag, excluded) {
+	const typeName = `${describe.name}${suffix}`;
+	const excludedNames = new Set(excluded.map((name) => name.toLowerCase()));
+	const allowed = sortedFields(describe).filter((field) => field[flag] && !excludedNames.has(field.name.toLowerCase()));
+	if (allowed.length === 0) return `export type ${typeName} = Record<string, never>;`;
+	const required = suffix === "CreateInput" ? allowed.filter((field) => !field.nillable && !field.defaultedOnCreate).map((field) => field.name) : [];
+	const optional = allowed.map((field) => field.name).filter((name) => !required.includes(name));
+	const parts = [];
+	if (required.length > 0) parts.push(`Pick<${describe.name}, ${keyUnion(required)}>`);
+	if (optional.length > 0) parts.push(`Partial<Pick<${describe.name}, ${keyUnion(optional)}>>`);
+	return `export type ${typeName} = ${parts.join(" & ")};`;
+}
+function registry(describes, names) {
+	return [
+		"/**",
+		" * Maps every generated sObject to its read, create and update types and its relationships.",
+		" * Pass it to the client: `new SalesforceClient<SObjectRegistry>({ ... })`.",
+		" */",
+		"export interface SObjectRegistry {",
+		...describes.map((describe) => registryEntry(describe, names)),
+		"}"
+	].join("\n");
+}
+function registryEntry(describe, names) {
+	const parents = describe.fields.filter((field) => field.relationshipName && field.referenceTo.length === 1 && names.has(field.referenceTo[0]) && IDENTIFIER$1.test(field.relationshipName)).map((field) => [field.relationshipName, field.referenceTo[0]]);
+	const children = describe.childRelationships.filter((relationship) => relationship.relationshipName && names.has(relationship.childSObject) && IDENTIFIER$1.test(relationship.relationshipName)).map((relationship) => [relationship.relationshipName, relationship.childSObject]);
+	return [
+		`\t${describe.name}: {`,
+		`\t\tread: ${describe.name};`,
+		`\t\tcreate: ${describe.name}CreateInput;`,
+		`\t\tupdate: ${describe.name}UpdateInput;`,
+		`\t\tparents: ${relationshipMap(parents)};`,
+		`\t\tchildren: ${relationshipMap(children)};`,
+		`\t\texternalIds: ${unionOrNever(externalIdFields(describe))};`,
+		`\t\tfieldKinds: ${fieldKindMap(describe)};`,
+		`\t\trecordTypes: ${unionOrNever(recordTypeNames(describe))};`,
+		`\t\tpolymorphicParents: ${polymorphicMap(describe)};`,
+		"	};"
+	].join("\n");
+}
+/** `Id` plus every field marked `externalId` or `idLookup`: the fields upsert accepts. */
+function externalIdFields(describe) {
+	const names = describe.fields.filter((field) => field.name === "Id" || field.externalId === true || field.idLookup === true).map((field) => field.name);
+	return [...new Set(names)].sort(compare);
+}
+function recordTypeNames(describe) {
+	const names = (describe.recordTypeInfos ?? []).map((info) => info.developerName);
+	return [...new Set(names.filter((name) => typeof name === "string" && name.length > 0))].sort(compare);
+}
+function fieldKindMap(describe) {
+	const lines = sortedFields(describe).filter((field) => FIELD_KINDS.has(field.type)).map((field) => `\t\t\t${propertyKey(field.name)}: ${JSON.stringify(field.type)};`);
+	return lines.length > 0 ? `{\n${lines.join("\n")}\n\t\t}` : "Record<never, never>";
+}
+/** Lookups with more than one target (e.g. `Owner` -> User or Group); `parents` leaves these out. */
+function polymorphicMap(describe) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const field of sortedFields(describe)) {
+		const name = field.relationshipName;
+		if (name && field.referenceTo.length > 1 && IDENTIFIER$1.test(name) && !entries.has(name)) entries.set(name, unionOrNever([...field.referenceTo].sort(compare)));
+	}
+	const lines = [...entries.entries()].sort(([a], [b]) => compare(a, b)).map(([name, targets]) => `\t\t\t${name}: ${targets};`);
+	return lines.length > 0 ? `{\n${lines.join("\n")}\n\t\t}` : "Record<never, never>";
+}
+/** `PICKLIST_VALUES`: the active values of every picklist and multi-select picklist field. */
+function picklistConstants(describes) {
+	const entries = describes.map(picklistEntry).filter((entry) => entry.length > 0);
+	return ["/** Active picklist values per sObject and field, e.g. to loop over every status in a test. */", `export const PICKLIST_VALUES = {${entries.length > 0 ? `\n${entries.join("\n")}\n` : ""}} as const;`].join("\n");
+}
+/** One sObject's entry in `PICKLIST_VALUES`, or `""` when it has no picklists. */
+function picklistEntry(describe) {
+	const fields = sortedFields(describe).map((field) => [field.name, activePicklistValues(field)]).filter(([, values]) => values.length > 0).map(([name, values]) => `\t\t${propertyKey(name)}: [${values.map((value) => JSON.stringify(value)).join(", ")}],`);
+	return fields.length > 0 ? `\t${describe.name}: {\n${fields.join("\n")}\n\t},` : "";
+}
+/** `RECORD_TYPES`: the record type DeveloperNames per sObject. */
+function recordTypeConstants(describes) {
+	const entries = describes.map((describe) => [describe.name, recordTypeNames(describe)]).filter(([, names]) => names.length > 0).map(([name, names]) => `\t${name}: [${names.map((value) => JSON.stringify(value)).join(", ")}],`);
+	return ["/** Record type DeveloperNames per sObject. Resolve ids with `sf.sobject(name).recordTypeId(developerName)`. */", `export const RECORD_TYPES = {${entries.length > 0 ? `\n${entries.join("\n")}\n` : ""}} as const;`].join("\n");
+}
+function activePicklistValues(field) {
+	if (field.type !== "picklist" && field.type !== "multipicklist" && field.type !== "combobox") return [];
+	return [...new Set((field.picklistValues ?? []).filter((entry) => entry.active).map((entry) => entry.value))];
+}
+function unionOrNever(values) {
+	return values.length > 0 ? values.map((value) => JSON.stringify(value)).join(" | ") : "never";
+}
+function apiVersionConstant(apiVersion) {
+	if (!/^v\d+\.\d+$/.test(apiVersion)) throw new Error(`Invalid apiVersion "${apiVersion}".`);
+	return [
+		"/**",
+		" * The API version these types were generated with. Pass it to the client so requests use the",
+		" * same version: `new SalesforceClient<SObjectRegistry>({ apiVersion: API_VERSION, ... })`.",
+		" */",
+		`export const API_VERSION = ${JSON.stringify(apiVersion)};`
+	].join("\n");
+}
+function relationshipMap(entries) {
+	const unique = /* @__PURE__ */ new Map();
+	for (const [name, target] of entries) if (!unique.has(name)) unique.set(name, target);
+	if (unique.size === 0) return "Record<never, never>";
+	return `{\n${[...unique.entries()].sort(([a], [b]) => compare(a, b)).map(([name, target]) => `\t\t\t${name}: ${JSON.stringify(target)};`).join("\n")}\n\t\t}`;
+}
+function keyUnion(names) {
+	return names.map((name) => JSON.stringify(name)).join(" | ");
+}
+function propertyKey(name) {
+	return IDENTIFIER$1.test(name) ? name : JSON.stringify(name);
+}
+function escapeComment(value) {
+	return String(value ?? "").replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+}
+function compare(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+//#endregion
+//#region src/codegen/validate-config.ts
+/** Thrown when a codegen config is invalid. Lists every problem found. */
+var CodegenConfigError = class extends Error {
+	source;
+	problems;
+	name = "CodegenConfigError";
+	constructor(source, problems) {
+		super(`Invalid sobjectly config (${source}):\n${problems.map((problem) => `  - ${problem}`).join("\n")}`);
+		this.source = source;
+		this.problems = problems;
+	}
+};
+/** The env-variable options each env-based auth type accepts. */
+const AUTH_OPTIONS = {
+	clientCredentials: [
+		"loginUrlEnv",
+		"clientIdEnv",
+		"clientSecretEnv"
+	],
+	accessToken: ["accessTokenEnv", "instanceUrlEnv"],
+	jwtBearer: [
+		"loginUrlEnv",
+		"clientIdEnv",
+		"usernameEnv",
+		"privateKeyEnv",
+		"privateKeyPathEnv"
+	],
+	sfCli: ["targetOrg"]
+};
+const PICKLIST_MODES = ["union", "string"];
+const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_]*$/;
+const VALIDATORS = {
+	$schema: (value, { problem }) => {
+		if (typeof value !== "string") problem("$schema: must be a string.");
+	},
+	output: (value, { problem }) => {
+		if (value === void 0) problem("output: required, e.g. \"src/generated/sobjects.ts\".");
+		else if (typeof value !== "string" || !/\.(ts|mts|cts)$/.test(value)) problem(`output: must be a TypeScript file path such as "src/generated/sobjects.ts", got ${show(value)}.`);
+	},
+	apiVersion: (value, { problem }) => {
+		if (value === void 0 || value === "") problem("apiVersion: required, e.g. \"v66.0\".");
+		else if (!require_sf_cli.isApiVersion(value)) problem(`apiVersion: must look like "v66.0", got ${show(value)}.`);
+	},
+	sobjects: (value, { problem }) => validateNames("sobjects", value, problem),
+	exclude: (value, { problem }) => validateNames("exclude", value, problem),
+	auth: validateAuth,
+	excludeCreateFields: (value, context) => validateFieldMap("excludeCreateFields", value, context),
+	excludeUpdateFields: (value, context) => validateFieldMap("excludeUpdateFields", value, context),
+	picklists: (value, { problem }) => {
+		if (!PICKLIST_MODES.includes(value)) problem(`picklists: must be "union" or "string", got ${show(value)}.`);
+	},
+	constants: (value, { problem }) => {
+		if (typeof value !== "boolean") problem(`constants: must be true or false, got ${show(value)}.`);
+	},
+	concurrency: (value, { problem }) => {
+		if (!Number.isInteger(value) || value < 1) problem(`concurrency: must be a positive integer, got ${show(value)}.`);
+	},
+	continueOnDescribeError: (value, { problem }) => {
+		if (typeof value !== "boolean") problem(`continueOnDescribeError: must be true or false, got ${show(value)}.`);
+	},
+	importSource: (value, { problem }) => {
+		if (typeof value !== "string" || value.length === 0) problem(`importSource: must be a non-empty string, got ${show(value)}.`);
+	},
+	format: (value, { problem, json }) => {
+		if (json) problem("format: only supported in a TypeScript config.");
+		else if (typeof value !== "function") problem("format: must be a function (source, filePath) => string.");
+	},
+	transport: (value, { problem, json }) => {
+		if (json) problem("transport: only supported in a TypeScript config.");
+		else if (typeof value?.send !== "function") problem("transport: must be an HttpTransport (an object with a send() method).");
+	}
+};
+/** The options a config may contain. */
+const CONFIG_OPTIONS = Object.keys(VALIDATORS).filter((key) => key !== "$schema");
+/**
+* Checks a loaded config and returns it typed. Throws a `CodegenConfigError` listing every
+* problem. `json` disallows the options that only a TypeScript config can express.
+*/
+function validateConfig(value, options) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new CodegenConfigError(options.source, ["the config must be an object (export default defineConfig({ ... }) or a JSON object)."]);
+	const problems = [];
+	const context = {
+		config: value,
+		json: options.json ?? false,
+		problem: (message) => problems.push(message)
+	};
+	for (const required of ["apiVersion", "output"]) if (!(required in value)) VALIDATORS[required]?.(void 0, context);
+	for (const [key, option] of Object.entries(value)) {
+		const validate = VALIDATORS[key];
+		if (!validate) problems.push(`${key}: unknown option. Valid options: ${CONFIG_OPTIONS.join(", ")}.`);
+		else if (option !== void 0 || key === "apiVersion" || key === "output") validate(option, context);
+	}
+	if (problems.length > 0) {
+		if (problems.some((problem) => problem.startsWith("apiVersion") || problem.startsWith("output"))) problems.push("Run \"npx sobjectly init\" to create a valid config.");
+		throw new CodegenConfigError(options.source, problems);
+	}
+	const { $schema: _schema, ...config } = value;
+	return config;
+}
+function validateNames(key, value, problem) {
+	if (!Array.isArray(value)) {
+		problem(`${key}: must be an array of sObject API names, got ${show(value)}.`);
+		return;
+	}
+	if (key === "sobjects" && value.length === 0) problem("sobjects: list at least one sObject, or leave it out to generate every queryable sObject.");
+	value.forEach((name, index) => {
+		if (typeof name !== "string" || !IDENTIFIER.test(name)) problem(`${key}[${index}]: ${show(name)} is not a valid sObject API name.`);
+	});
+}
+function validateFieldMap(key, value, { config, problem }) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		problem(`${key}: must be an object like { "Account": ["FieldName"] }, got ${show(value)}.`);
+		return;
+	}
+	const listed = Array.isArray(config.sobjects) ? new Set(config.sobjects.map((name) => typeof name === "string" ? name.toLowerCase() : name)) : void 0;
+	for (const [sobject, fields] of Object.entries(value)) {
+		if (listed && !listed.has(sobject.toLowerCase())) problem(`${key}.${sobject}: "${sobject}" is not listed in sobjects.`);
+		if (!Array.isArray(fields) || fields.some((field) => typeof field !== "string" || field.length === 0)) problem(`${key}.${sobject}: must be an array of field API names, got ${show(fields)}.`);
+	}
+}
+function validateAuth(value, { json, problem }) {
+	if (typeof value !== "object" || value === null) {
+		problem(`auth: must be an object like { "type": "clientCredentials" }, got ${show(value)}.`);
+		return;
+	}
+	if (typeof value.getToken === "function") {
+		if (json) problem("auth: auth providers are only supported in a TypeScript config.");
+		return;
+	}
+	const { type, ...rest } = value;
+	const allowed = AUTH_OPTIONS[type];
+	if (!allowed) {
+		problem(`auth.type: must be one of ${Object.keys(AUTH_OPTIONS).join(", ")}, got ${show(type)}.`);
+		return;
+	}
+	for (const [key, option] of Object.entries(rest)) if (!allowed.includes(key)) problem(`auth.${key}: not an option of "${String(type)}". Valid options: ${allowed.join(", ")}.`);
+	else if (typeof option !== "string" || option.length === 0) problem(`auth.${key}: must be a non-empty string, got ${show(option)}.`);
+}
+function show(value) {
+	if (value === void 0) return "undefined";
+	if (typeof value === "function") return "a function";
+	try {
+		return JSON.stringify(value) ?? typeof value;
+	} catch {
+		return typeof value;
+	}
+}
+//#endregion
+//#region src/codegen/config.ts
+/**
+* Type-checks a `sobjectly.config.ts`. The listed `sobjects` become a literal union, so a typo in
+* a per-sObject option is a compile error:
+*
+* ```ts
+* export default defineConfig({
+* 	apiVersion: "v66.0",
+* 	output: "src/generated/sobjects.ts",
+* 	sobjects: ["Account", "Contact"],
+* 	excludeCreateFields: { Acount: ["Name"] }, // ❌ "Acount" is not in sobjects
+* });
+* ```
+*/
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+//#region src/codegen/load-config.ts
+/** Config file names, in lookup order. */
+const CONFIG_FILE_NAMES = [
+	"sobjectly.config.ts",
+	"sobjectly.config.mts",
+	"sobjectly.config.cts",
+	"sobjectly.config.json"
+];
+const TYPESCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".mts",
+	".cts"
+]);
+/** Looks for a `sobjectly.config.{ts,mts,cts,json}` file in `cwd`; the first match in lookup order wins. */
+function findConfigFile(cwd = process.cwd()) {
+	return findConfigFiles(cwd)[0];
+}
+/** Every `sobjectly.config.*` file in `cwd`, in lookup order. */
+function findConfigFiles(cwd = process.cwd()) {
+	return CONFIG_FILE_NAMES.map((name) => (0, node_path.join)(cwd, name)).filter((path) => (0, node_fs.existsSync)(path));
+}
+/**
+* Loads and validates a TypeScript (`.ts`, `.mts`, `.cts`) or JSON config file. Returns the
+* config and the directory it lives in. Throws a `CodegenConfigError` listing every problem.
+*/
+async function loadConfig(configPath) {
+	const absolutePath = (0, node_path.resolve)(configPath);
+	if (!(0, node_fs.existsSync)(absolutePath)) throw new Error(`Config file not found: ${absolutePath}`);
+	const extension = (0, node_path.extname)(absolutePath).toLowerCase();
+	const directory = (0, node_path.dirname)(absolutePath);
+	if (extension === ".json") return {
+		config: validateConfig(readJson(absolutePath), {
+			source: absolutePath,
+			json: true
+		}),
+		directory
+	};
+	if (!TYPESCRIPT_EXTENSIONS.has(extension)) throw new Error(`Unsupported config file "${absolutePath}". Use sobjectly.config.ts or sobjectly.config.json.`);
+	return {
+		config: validateConfig(await (0, jiti.createJiti)((0, node_path.join)(directory, "_sobjectly_loader.js"), { interopDefault: true }).import(absolutePath, { default: true }), { source: absolutePath }),
+		directory
+	};
+}
+function readJson(path) {
+	try {
+		return JSON.parse((0, node_fs.readFileSync)(path, "utf8"));
+	} catch (error) {
+		throw new CodegenConfigError(path, [`not valid JSON: ${error instanceof Error ? error.message : String(error)}`]);
+	}
+}
+//#endregion
+//#region src/codegen/init.ts
+const SOBJECT_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
+const NPM_SCRIPT = "sobjects:generate";
+/** The environment variables each auth type reads by default. */
+const AUTH_ENV_VARS = {
+	clientCredentials: [
+		"SF_LOGIN_URL",
+		"SF_CLIENT_ID",
+		"SF_CLIENT_SECRET"
+	],
+	accessToken: ["SF_ACCESS_TOKEN", "SF_INSTANCE_URL"],
+	jwtBearer: [
+		"SF_LOGIN_URL",
+		"SF_CLIENT_ID",
+		"SF_USERNAME",
+		"SF_PRIVATE_KEY_PATH"
+	],
+	sfCli: []
+};
+const AUTH_CHOICES = [
+	{
+		value: "clientCredentials",
+		label: "Client credentials (recommended for CI and test automation)"
+	},
+	{
+		value: "sfCli",
+		label: "Salesforce CLI org (recommended for local development; no secrets needed)"
+	},
+	{
+		value: "accessToken",
+		label: "Access token (e.g. from `sf org display`)"
+	},
+	{
+		value: "jwtBearer",
+		label: "JWT bearer (certificate-based, runs as a user)"
+	}
+];
+const PICKLIST_CHOICES = [{
+	value: "union",
+	label: "Union of values, e.g. \"New\" | \"Closed\" (type-safe)"
+}, {
+	value: "string",
+	label: "Plain string"
+}];
+const FORMAT_CHOICES = [{
+	value: "ts",
+	label: "TypeScript (sobjectly.config.ts, type-checked with defineConfig)"
+}, {
+	value: "json",
+	label: "JSON (sobjectly.config.json, validated with a JSON Schema)"
+}];
+/**
+* Creates a `sobjectly.config` file by asking for the API version, output path, sObjects, auth
+* method, picklist mode and file format. Optionally adds the auth variables to `.env.example`
+* and an npm script to `package.json`.
+*/
+async function runInit(options) {
+	const { cwd, prompter, log } = options;
+	const existing = findConfigFiles(cwd);
+	if (existing.length > 0 && !options.force) {
+		const names = existing.map((path) => (0, node_path.relative)(cwd, path)).join(" and ");
+		if (!(options.yes ? false : await prompter.confirm(`${names} already exists. Replace it?`, false))) {
+			log(`Kept the existing ${names}.`);
+			return { configPath: void 0 };
+		}
+	}
+	validatePreset(options.preset ?? {});
+	const answers = await askQuestions(options);
+	const configPath = (0, node_path.join)(cwd, `sobjectly.config.${answers.format}`);
+	for (const path of existing.filter((path) => path !== configPath)) {
+		(0, node_fs.rmSync)(path);
+		log(`Removed ${(0, node_path.relative)(cwd, path)}`);
+	}
+	(0, node_fs.writeFileSync)(configPath, renderConfig(answers), "utf8");
+	log(`\nCreated ${(0, node_path.relative)(cwd, configPath)}`);
+	const envExampleUpdated = await maybeUpdateEnvExample(options, answers.auth);
+	const scriptAdded = await maybeAddScript(options);
+	printNextSteps(log, answers, scriptAdded, cwd);
+	return {
+		configPath,
+		answers,
+		envExampleUpdated,
+		scriptAdded
+	};
+}
+async function askQuestions(options) {
+	const { prompter, preset = {}, yes } = options;
+	const apiVersion = preset.apiVersion ?? await askApiVersion(prompter, yes);
+	const output = preset.output ?? (yes ? "src/generated/sobjects.ts" : await prompter.ask("Where should the generated types be written?", {
+		defaultValue: "src/generated/sobjects.ts",
+		validate: validateOutput
+	}));
+	const sobjects = preset.sobjects ?? await askSObjects(prompter, yes);
+	const auth = preset.auth ?? (yes ? "clientCredentials" : await prompter.choose("How should the generator log in to Salesforce?", AUTH_CHOICES, "clientCredentials"));
+	const targetOrg = auth === "sfCli" ? preset.targetOrg ?? await askTargetOrg(prompter, yes) : void 0;
+	const picklists = preset.picklists ?? (yes ? "union" : await prompter.choose("How should picklist fields be typed?", PICKLIST_CHOICES, "union"));
+	const format = preset.format ?? (yes ? "ts" : await prompter.choose("Which config file format?", FORMAT_CHOICES, "ts"));
+	return {
+		apiVersion,
+		output,
+		sobjects,
+		auth,
+		...targetOrg ? { targetOrg } : {},
+		picklists,
+		format
+	};
+}
+async function askTargetOrg(prompter, yes) {
+	if (yes) return;
+	const answer = await prompter.ask("Which Salesforce CLI org alias? Leave empty to use the CLI's default org", { validate: (value) => value === "" || /^[\w.@+-]+$/.test(value) ? void 0 : "Enter an org alias or username." });
+	return answer === "" ? void 0 : answer;
+}
+async function askApiVersion(prompter, yes) {
+	if (yes) throw new Error("An API version is required: pass --api-version (e.g. --api-version v66.0).");
+	const answer = await prompter.ask("Which Salesforce API version should be used? (e.g. v66.0; your org lists them at https://<my-domain>.my.salesforce.com/services/data/)", { validate: (value) => require_sf_cli.normalizeApiVersion(value) ? void 0 : "Enter a version like \"v66.0\" or \"66\"." });
+	return require_sf_cli.normalizeApiVersion(answer);
+}
+async function askSObjects(prompter, yes) {
+	const defaultValue = "Account, Contact";
+	return parseSObjects(yes ? defaultValue : await prompter.ask("Which sObjects do you want types for? Use comma-separated API names", {
+		defaultValue,
+		validate: validateSObjects
+	}));
+}
+/** Splits a comma/space separated list of sObject names, removing duplicates. */
+function parseSObjects(answer) {
+	return [...new Set(answer.split(/[\s,]+/).filter((name) => name.length > 0))];
+}
+function validateSObjects(answer) {
+	return validateSObjectNames(parseSObjects(answer));
+}
+function validateSObjectNames(names) {
+	if (names.length === 0) return "Enter at least one sObject, e.g. Account.";
+	const invalid = names.filter((name) => !SOBJECT_NAME.test(name));
+	return invalid.length > 0 ? `Not a valid sObject API name: ${invalid.join(", ")}` : void 0;
+}
+/** Answers given as flags get the same checks as typed answers. */
+function validatePreset(preset) {
+	const errors = [
+		preset.sobjects === void 0 ? void 0 : validateSObjectNames(preset.sobjects),
+		preset.output === void 0 ? void 0 : validateOutput(preset.output),
+		preset.targetOrg === void 0 || /^[\w.@+-]+$/.test(preset.targetOrg) ? void 0 : `Invalid org alias "${preset.targetOrg}".`
+	].filter((error) => error !== void 0);
+	if (errors.length > 0) throw new Error(errors.join(" "));
+}
+function validateOutput(answer) {
+	return /\.(ts|mts|cts)$/.test(answer) ? void 0 : "The output must be a TypeScript file, e.g. src/generated/sobjects.ts.";
+}
+/** The `$schema` reference written into `sobjectly.config.json`. */
+const JSON_SCHEMA_REFERENCE = "./node_modules/@cerios/salesforce-sobjectly/sobjectly.config.schema.json";
+/** Renders the config file in the chosen format. */
+function renderConfig(answers) {
+	return answers.format === "json" ? renderJsonConfig(answers) : renderTypeScriptConfig(answers);
+}
+function renderJsonConfig(answers) {
+	const config = {
+		$schema: JSON_SCHEMA_REFERENCE,
+		apiVersion: answers.apiVersion,
+		output: answers.output,
+		sobjects: answers.sobjects,
+		auth: authSetting(answers),
+		picklists: answers.picklists
+	};
+	return `${JSON.stringify(config, null, "	")}\n`;
+}
+function renderTypeScriptConfig(answers) {
+	const envVars = AUTH_ENV_VARS[answers.auth];
+	const sobjects = answers.sobjects.map((name) => JSON.stringify(name)).join(", ");
+	return [
+		"import { defineConfig } from \"@cerios/salesforce-sobjectly/codegen\";",
+		"",
+		"export default defineConfig({",
+		"	// The Salesforce REST API version. The generated file exports it as API_VERSION for the client.",
+		`\tapiVersion: ${JSON.stringify(answers.apiVersion)},`,
+		"	// Where the generated types are written, relative to this file.",
+		`\toutput: ${JSON.stringify(answers.output)},`,
+		"	// The sObjects to generate types for.",
+		`\tsobjects: [${sobjects}],`,
+		`\t// ${authComment(answers.auth, envVars)}`,
+		`\tauth: ${renderAuth(answers)},`,
+		`\tpicklists: ${JSON.stringify(answers.picklists)},`,
+		"});",
+		""
+	].join("\n");
+}
+function authSetting(answers) {
+	return answers.auth === "sfCli" && answers.targetOrg ? {
+		type: "sfCli",
+		targetOrg: answers.targetOrg
+	} : { type: answers.auth };
+}
+function renderAuth(answers) {
+	const setting = authSetting(answers);
+	const targetOrg = setting.targetOrg ? `, targetOrg: ${JSON.stringify(setting.targetOrg)}` : "";
+	return `{ type: ${JSON.stringify(setting.type)}${targetOrg} }`;
+}
+function authComment(auth, envVars) {
+	return auth === "sfCli" ? "Uses an org you are logged into with the Salesforce CLI (sf org login web)." : `Reads ${formatList(envVars)} from the environment.`;
+}
+async function maybeUpdateEnvExample(options, auth) {
+	const path = (0, node_path.join)(options.cwd, ".env.example");
+	const content = (0, node_fs.existsSync)(path) ? (0, node_fs.readFileSync)(path, "utf8") : "";
+	const missing = AUTH_ENV_VARS[auth].filter((name) => !new RegExp(`^${name}=`, "m").test(content));
+	if (missing.length === 0) return false;
+	if (!(options.yes === true || await options.prompter.confirm(`Add ${formatList(missing)} to .env.example?`, true))) return false;
+	const block = ["# Salesforce credentials for `sobjectly generate`", ...missing.map((name) => `${name}=`)].join("\n");
+	const separator = content.length === 0 ? "" : content.endsWith("\n") ? "\n" : "\n\n";
+	(0, node_fs.writeFileSync)(path, `${content}${separator}${block}\n`, "utf8");
+	options.log("Updated .env.example");
+	return true;
+}
+async function maybeAddScript(options) {
+	const path = (0, node_path.join)(options.cwd, "package.json");
+	if (!(0, node_fs.existsSync)(path)) return false;
+	const raw = (0, node_fs.readFileSync)(path, "utf8");
+	const bom = raw.startsWith("") ? "" : "";
+	let pkg;
+	try {
+		pkg = JSON.parse(raw.slice(bom.length));
+	} catch {
+		options.log(`Skipped adding the "${NPM_SCRIPT}" script: package.json is not valid JSON.`);
+		return false;
+	}
+	if (pkg.scripts?.[NPM_SCRIPT]) return false;
+	if (!(options.yes === true || await options.prompter.confirm(`Add an npm script "${NPM_SCRIPT}"?`, true))) return false;
+	pkg.scripts = {
+		...pkg.scripts,
+		[NPM_SCRIPT]: "sobjectly generate"
+	};
+	const indent = /^[ \t]+/m.exec(raw)?.[0] ?? "	";
+	const newline = raw.includes("\r\n") ? "\r\n" : "\n";
+	const json = JSON.stringify(pkg, null, indent).replace(/\n/g, newline);
+	(0, node_fs.writeFileSync)(path, `${bom}${json}${newline}`, "utf8");
+	options.log(`Added the "${NPM_SCRIPT}" script to package.json`);
+	return true;
+}
+function printNextSteps(log, answers, scriptAdded, cwd) {
+	const cli = answers.auth === "sfCli";
+	const envFile = cli ? "" : " --env-file .env";
+	const command = scriptAdded ? `npm run ${NPM_SCRIPT}${envFile ? ` --${envFile}` : ""}` : `npx sobjectly generate${envFile}`;
+	const gitignore = (0, node_path.join)(cwd, ".gitignore");
+	const envIgnored = (0, node_fs.existsSync)(gitignore) && /^\.env\b/m.test((0, node_fs.readFileSync)(gitignore, "utf8"));
+	log([
+		"",
+		"Next steps:",
+		cli ? `  1. Log in with the Salesforce CLI: sf org login web${answers.targetOrg ? ` --alias ${answers.targetOrg}` : " --set-default"}` : `  1. Put ${formatList(AUTH_ENV_VARS[answers.auth])} in a .env file${envIgnored ? "" : " (and add .env to .gitignore)"}.`,
+		`  2. Generate the types: ${command}`,
+		"  3. Use them:",
+		`       import { API_VERSION, type SObjectRegistry } from "./${answers.output.replace(/\.(ts|mts|cts)$/, "")}";`,
+		"       const sf = new SalesforceClient<SObjectRegistry>({ apiVersion: API_VERSION, auth });"
+	].join("\n"));
+}
+function formatList(items) {
+	if (items.length <= 1) return items.join("");
+	return `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+}
+//#endregion
+//#region src/codegen/prompter.ts
+/**
+* A prompter on stdin/stdout (or the given streams). Lines are queued as they arrive, so piped
+* input (`printf "v66.0\n..." | sobjectly init`) works too. If the input ends before a question
+* is answered, the question rejects.
+*/
+function readlinePrompter(input = process.stdin, output = process.stdout) {
+	const interactive = input.isTTY === true;
+	const rl = (0, node_readline.createInterface)({
+		input,
+		output,
+		terminal: interactive
+	});
+	const lines = [];
+	let waiting;
+	let closed = false;
+	rl.on("line", (line) => {
+		if (waiting) {
+			const { resolve } = waiting;
+			waiting = void 0;
+			resolve(line);
+		} else lines.push(line);
+	});
+	rl.on("close", () => {
+		closed = true;
+		waiting?.reject(/* @__PURE__ */ new Error("Input ended before all questions were answered."));
+		waiting = void 0;
+	});
+	const readLine = (prompt) => {
+		if (closed) output.write(prompt);
+		else {
+			rl.setPrompt(prompt);
+			rl.prompt();
+		}
+		const queued = lines.shift();
+		if (queued !== void 0) {
+			if (!interactive) output.write(`${queued}\n`);
+			return Promise.resolve(queued);
+		}
+		if (closed) return Promise.reject(/* @__PURE__ */ new Error("Input ended before all questions were answered."));
+		return new Promise((resolve, reject) => {
+			waiting = {
+				resolve: (line) => {
+					if (!interactive) output.write(`${line}\n`);
+					resolve(line);
+				},
+				reject
+			};
+		});
+	};
+	const ask = async (question, options = {}) => {
+		const suffix = options.defaultValue ? ` (${options.defaultValue})` : "";
+		for (;;) {
+			const raw = (await readLine(`? ${question}${suffix}: `)).trim();
+			const answer = raw === "" ? options.defaultValue ?? "" : raw;
+			const error = options.validate?.(answer);
+			if (error === void 0) return answer;
+			output.write(`  ${error}\n`);
+		}
+	};
+	return {
+		ask,
+		async choose(question, choices, defaultValue) {
+			output.write(`? ${question}\n`);
+			choices.forEach((choice, index) => {
+				output.write(`  ${index + 1}) ${choice.label}${choice.value === defaultValue ? " (default)" : ""}\n`);
+			});
+			return (pick(choices, await ask("Choose a number", {
+				defaultValue: String(choices.findIndex((choice) => choice.value === defaultValue) + 1),
+				validate: (value) => pick(choices, value) ? void 0 : `Enter a number from 1 to ${choices.length}.`
+			})) ?? choices[0]).value;
+		},
+		async confirm(question, defaultValue) {
+			const answer = await ask(`${question} ${defaultValue ? "(Y/n)" : "(y/N)"}`, { validate: (value) => value === "" || /^(y|yes|n|no)$/i.test(value) ? void 0 : "Answer y or n." });
+			return answer === "" ? defaultValue : /^y/i.test(answer);
+		},
+		close() {
+			rl.close();
+		}
+	};
+}
+function pick(choices, answer) {
+	const index = Number(answer);
+	if (Number.isInteger(index) && index >= 1 && index <= choices.length) return choices[index - 1];
+	return choices.find((choice) => choice.value.toLowerCase() === answer.toLowerCase());
+}
+//#endregion
+//#region src/codegen/index.ts
+const silentLogger = {
+	info: () => void 0,
+	warn: () => void 0
+};
+/** Describes the configured sObjects and writes the generated types to `config.output`. */
+async function generate(input, options = {}) {
+	const logger = options.logger ?? silentLogger;
+	const built = await buildSource(input, options);
+	const { config } = built;
+	let source = built.raw;
+	if (config.format) source = await config.format(source, built.outputPath);
+	if (options.write !== false) {
+		await writeAtomically(built.outputPath, source);
+		logger.info(`Wrote ${built.sobjects.length} sObject type(s) to ${built.outputPath}`);
+	}
+	const { contentHash } = readGeneratedHashes(built.raw);
+	return {
+		outputPath: built.outputPath,
+		apiVersion: config.apiVersion,
+		sobjects: built.sobjects,
+		skipped: built.skipped,
+		source,
+		contentHash
+	};
+}
+/**
+* Checks whether the generated file on disk is up to date with the org, without writing it.
+* Only content counts: a file reformatted by Prettier, oxfmt or the `format` hook is up to date.
+*/
+async function checkGenerated(input, options = {}) {
+	const built = await buildSource(input, options);
+	const empty = {
+		outputPath: built.outputPath,
+		added: [],
+		removed: [],
+		changed: []
+	};
+	if (!(0, node_fs.existsSync)(built.outputPath)) return {
+		...empty,
+		upToDate: false,
+		reason: "missing"
+	};
+	const existing = await (0, node_fs_promises.readFile)(built.outputPath, "utf8");
+	const expected = readGeneratedHashes(built.raw);
+	const actual = readGeneratedHashes(existing);
+	if (!actual) {
+		const upToDate = normalizeSource(existing) === normalizeSource(built.raw);
+		return {
+			...empty,
+			upToDate,
+			reason: upToDate ? void 0 : "changed"
+		};
+	}
+	if (actual.contentHash === expected.contentHash) return {
+		...empty,
+		upToDate: true
+	};
+	return {
+		...empty,
+		upToDate: false,
+		reason: "changed",
+		...diffObjects(actual.sobjects, expected.sobjects)
+	};
+}
+async function buildSource(input, options) {
+	const config = validateConfig(input, { source: "generate()" });
+	const { apiVersion } = config;
+	const logger = options.logger ?? silentLogger;
+	const env = options.env ?? process.env;
+	const outputPath = (0, node_path.isAbsolute)(config.output) ? config.output : (0, node_path.resolve)(options.cwd ?? process.cwd(), config.output);
+	const client = new require_sf_cli.SalesforceClient({
+		auth: resolveAuth(config.auth, env),
+		apiVersion,
+		transport: config.transport,
+		retry: true
+	});
+	const names = await resolveSObjectNames(client, config, logger);
+	logger.info(`Describing ${names.length} sObject(s) with API ${apiVersion}...`);
+	const { describes, skipped } = await describeAll(client, names, config, logger);
+	return {
+		config,
+		outputPath,
+		raw: generateSource(describes, {
+			excludeCreateFields: config.excludeCreateFields,
+			excludeUpdateFields: config.excludeUpdateFields,
+			picklists: config.picklists,
+			constants: config.constants,
+			importSource: config.importSource,
+			apiVersion
+		}),
+		sobjects: describes.map((describe) => describe.name).sort(),
+		skipped
+	};
+}
+function diffObjects(actual, expected) {
+	return {
+		added: [...expected.keys()].filter((name) => !actual.has(name)),
+		removed: [...actual.keys()].filter((name) => !expected.has(name)),
+		changed: [...expected.entries()].filter(([name, hash]) => actual.has(name) && actual.get(name) !== hash).map(([name]) => name)
+	};
+}
+/** Strips comments, whitespace, quote style, semicolons and commas, so only content remains. */
+function normalizeSource(source) {
+	let result = "";
+	let index = 0;
+	while (index < source.length) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (char === "\"" || char === "'") {
+			let end = index + 1;
+			while (end < source.length && source[end] !== char) end += source[end] === "\\" ? 2 : 1;
+			result += `"${source.slice(index + 1, end).replace(/\\'/g, "'").replace(/"/g, "\\\"")}"`;
+			index = end + 1;
+		} else if (char === "/" && next === "/") index = source.indexOf("\n", index) === -1 ? source.length : source.indexOf("\n", index);
+		else if (char === "/" && next === "*") {
+			const end = source.indexOf("*/", index + 2);
+			index = end === -1 ? source.length : end + 2;
+		} else {
+			if (!/[\s;,]/.test(char)) result += char;
+			index++;
+		}
+	}
+	return result;
+}
+/** Turns the config's auth setting into an auth provider, reading env-based credentials. */
+function resolveAuth(auth, env) {
+	const setting = auth ?? { type: "clientCredentials" };
+	if ("getToken" in setting) return setting;
+	const read = (name) => {
+		const value = env[name];
+		if (!value) throw new Error(`Environment variable ${name} is not set.`);
+		return value;
+	};
+	switch (setting.type) {
+		case "accessToken": return require_sf_cli.accessToken({
+			accessToken: read(setting.accessTokenEnv ?? "SF_ACCESS_TOKEN"),
+			instanceUrl: read(setting.instanceUrlEnv ?? "SF_INSTANCE_URL")
+		});
+		case "jwtBearer": return jwtBearerFromEnv(setting, env, read);
+		case "sfCli": return require_sf_cli.sfCli({ targetOrg: setting.targetOrg });
+		case "clientCredentials": return require_sf_cli.clientCredentials({
+			loginUrl: read(setting.loginUrlEnv ?? "SF_LOGIN_URL"),
+			clientId: read(setting.clientIdEnv ?? "SF_CLIENT_ID"),
+			clientSecret: read(setting.clientSecretEnv ?? "SF_CLIENT_SECRET")
+		});
+		default: throw new Error(`Unknown codegen auth type "${setting.type}".`);
+	}
+}
+function jwtBearerFromEnv(setting, env, read) {
+	const keyEnv = setting.privateKeyEnv ?? "SF_PRIVATE_KEY";
+	const privateKey = env[keyEnv] ? read(keyEnv) : (0, node_fs.readFileSync)(read(setting.privateKeyPathEnv ?? "SF_PRIVATE_KEY_PATH"), "utf8");
+	return require_sf_cli.jwtBearer({
+		loginUrl: read(setting.loginUrlEnv ?? "SF_LOGIN_URL"),
+		clientId: read(setting.clientIdEnv ?? "SF_CLIENT_ID"),
+		username: read(setting.usernameEnv ?? "SF_USERNAME"),
+		privateKey
+	});
+}
+async function resolveSObjectNames(client, config, logger) {
+	const exclude = new Set((config.exclude ?? []).map((name) => name.toLowerCase()));
+	if (config.sobjects && config.sobjects.length > 0) {
+		const unique = /* @__PURE__ */ new Map();
+		for (const name of config.sobjects) if (!unique.has(name.toLowerCase())) unique.set(name.toLowerCase(), name);
+		return [...unique.entries()].filter(([key]) => !exclude.has(key)).map(([, name]) => name);
+	}
+	logger.warn("No `sobjects` configured: generating every queryable sObject. Consider an explicit list.");
+	return (await client.describeGlobal()).sobjects.filter((sobject) => sobject.queryable && !sobject.deprecatedAndHidden && !exclude.has(sobject.name.toLowerCase())).map((sobject) => sobject.name);
+}
+async function describeAll(client, names, config, logger) {
+	const concurrency = Math.max(1, config.concurrency ?? 10);
+	const describes = [];
+	const skipped = [];
+	let next = 0;
+	let done = 0;
+	const failed = new AbortController();
+	const worker = async () => {
+		while (next < names.length && !failed.signal.aborted) {
+			const name = names[next++];
+			try {
+				const describe = await client.sobject(name).describe({ signal: failed.signal });
+				describes.push(describe);
+			} catch (error) {
+				if (failed.signal.aborted) return;
+				const message = error instanceof Error ? error.message : String(error);
+				if (!config.continueOnDescribeError) {
+					failed.abort();
+					throw new Error(`Describing sObject "${name}" failed: ${message}`, { cause: error });
+				}
+				logger.warn(`Skipping sObject "${name}": ${message}`);
+				skipped.push({
+					name,
+					error: message
+				});
+			}
+			done++;
+			if (done % 10 === 0 || done === names.length) logger.info(`Described ${done}/${names.length} sObject(s)`);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(concurrency, names.length) }, () => worker()));
+	return {
+		describes: [...new Map(describes.map((describe) => [describe.name, describe])).values()],
+		skipped
+	};
+}
+async function writeAtomically(filePath, content) {
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(filePath), { recursive: true });
+	const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+	try {
+		await (0, node_fs_promises.writeFile)(temporary, content, "utf8");
+		await renameWithRetry(temporary, filePath);
+	} catch (error) {
+		await (0, node_fs_promises.rm)(temporary, { force: true });
+		throw error;
+	}
+}
+/** On Windows a virus scanner or indexer can briefly lock the target file; retry a few times. */
+async function renameWithRetry(from, to) {
+	for (let attempt = 1;; attempt++) try {
+		await (0, node_fs_promises.rename)(from, to);
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (attempt >= 5 || code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") throw error;
+		await new Promise((resolve) => setTimeout(resolve, 50 * attempt));
+	}
+}
+//#endregion
+Object.defineProperty(exports, "AUTH_ENV_VARS", {
+	enumerable: true,
+	get: function() {
+		return AUTH_ENV_VARS;
+	}
+});
+Object.defineProperty(exports, "AUTH_OPTIONS", {
+	enumerable: true,
+	get: function() {
+		return AUTH_OPTIONS;
+	}
+});
+Object.defineProperty(exports, "CONFIG_FILE_NAMES", {
+	enumerable: true,
+	get: function() {
+		return CONFIG_FILE_NAMES;
+	}
+});
+Object.defineProperty(exports, "CONFIG_OPTIONS", {
+	enumerable: true,
+	get: function() {
+		return CONFIG_OPTIONS;
+	}
+});
+Object.defineProperty(exports, "CodegenConfigError", {
+	enumerable: true,
+	get: function() {
+		return CodegenConfigError;
+	}
+});
+Object.defineProperty(exports, "FIELD_TYPE_MAP", {
+	enumerable: true,
+	get: function() {
+		return FIELD_TYPE_MAP;
+	}
+});
+Object.defineProperty(exports, "checkGenerated", {
+	enumerable: true,
+	get: function() {
+		return checkGenerated;
+	}
+});
+Object.defineProperty(exports, "defineConfig", {
+	enumerable: true,
+	get: function() {
+		return defineConfig;
+	}
+});
+Object.defineProperty(exports, "findConfigFile", {
+	enumerable: true,
+	get: function() {
+		return findConfigFile;
+	}
+});
+Object.defineProperty(exports, "findConfigFiles", {
+	enumerable: true,
+	get: function() {
+		return findConfigFiles;
+	}
+});
+Object.defineProperty(exports, "generate", {
+	enumerable: true,
+	get: function() {
+		return generate;
+	}
+});
+Object.defineProperty(exports, "generateSource", {
+	enumerable: true,
+	get: function() {
+		return generateSource;
+	}
+});
+Object.defineProperty(exports, "loadConfig", {
+	enumerable: true,
+	get: function() {
+		return loadConfig;
+	}
+});
+Object.defineProperty(exports, "mapFieldType", {
+	enumerable: true,
+	get: function() {
+		return mapFieldType;
+	}
+});
+Object.defineProperty(exports, "parseSObjects", {
+	enumerable: true,
+	get: function() {
+		return parseSObjects;
+	}
+});
+Object.defineProperty(exports, "readGeneratedHashes", {
+	enumerable: true,
+	get: function() {
+		return readGeneratedHashes;
+	}
+});
+Object.defineProperty(exports, "readlinePrompter", {
+	enumerable: true,
+	get: function() {
+		return readlinePrompter;
+	}
+});
+Object.defineProperty(exports, "renderConfig", {
+	enumerable: true,
+	get: function() {
+		return renderConfig;
+	}
+});
+Object.defineProperty(exports, "resolveAuth", {
+	enumerable: true,
+	get: function() {
+		return resolveAuth;
+	}
+});
+Object.defineProperty(exports, "runInit", {
+	enumerable: true,
+	get: function() {
+		return runInit;
+	}
+});
+Object.defineProperty(exports, "validateConfig", {
+	enumerable: true,
+	get: function() {
+		return validateConfig;
+	}
+});
+
+//# sourceMappingURL=codegen-BgDgU2RR.cjs.map