const argv1CandidateCache = new Map<string, string[]>();

function parsePackageName(raw: string): string | null {

const parsed = JSON.parse(raw) as { name?: unknown };

return typeof parsed.name === "string" ? parsed.name : null;

const parsed: unknown = JSON.parse(raw);

return parsed && typeof parsed === "object" && "name" in parsed && typeof parsed.name === "string"

? parsed.name

: null;

}

async function readPackageName(dir: string): Promise<string | null> {

function readPackageName(packageJsonPath: string): string | null {

try {

const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as { name?: unknown };

return typeof parsed.name === "string" ? parsed.name : null;

const parsed: unknown = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));

return parsed &&

typeof parsed === "object" &&

"name" in parsed &&

typeof parsed.name === "string"

? parsed.name

: null;

} catch {

return null;

}

if (!this.#entries.has(cacheKey)) {

return { hit: false };

}

// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Map.has proves the value exists while preserving caller-specific cache value type.

const cached = this.#entries.get(cacheKey) as T;

this.#entries.delete(cacheKey);

this.#entries.set(cacheKey, cached);

params.cache.set(params.config, configCache);

}

if (configCache.has(params.key)) {

// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Map.has proves the value exists while preserving caller-specific cache value type.

return configCache.get(params.key) as T;

}

const loaded = params.load();

sourceTransformTargets: new Map<string, number>(),

};

function isJitiLoaderModule(value: unknown): value is { createJiti: PluginModuleLoaderFactory } {

const canHaveProperties = (value && typeof value === "object") || typeof value === "function";

return Boolean(

canHaveProperties && "createJiti" in value && typeof value.createJiti === "function",

);

}

function recordSourceTransformTarget(target: string): void {

const current = pluginModuleLoaderStats.sourceTransformTargets.get(target) ?? 0;

pluginModuleLoaderStats.sourceTransformTargets.set(target, current + 1);

if (createJitiLoaderFactory) {

return createJitiLoaderFactory;

}

const loaded = requireForJiti("jiti") as { createJiti?: PluginModuleLoaderFactory };

if (typeof loaded.createJiti !== "function") {

const loaded: unknown = requireForJiti("jiti");

if (!isJitiLoaderModule(loaded)) {

throw new Error("jiti module did not export createJiti");

}

createJitiLoaderFactory = loaded.createJiti;

autoStart: ResolvedTranscriptsAutoStartConfig[];

};

function isRecord(value: unknown): value is Record<string, unknown> {

return Boolean(value && typeof value === "object" && !Array.isArray(value));

}

function resolveAutoStart(raw: unknown): ResolvedTranscriptsAutoStartConfig[] {

if (!Array.isArray(raw)) {

return [];

}

return raw

.map((entry): ResolvedTranscriptsAutoStartConfig | undefined => {

const config = entry && typeof entry === "object" ? (entry as Record<string, unknown>) : {};

const config = isRecord(entry) ? entry : {};

const providerId = readString(config.providerId);

if (!providerId) {

return undefined;

}

export function resolveTranscriptsConfig(raw: unknown): ResolvedTranscriptsConfig {

const config = raw && typeof raw === "object" ? (raw as Record<string, unknown>) : {};

const config = isRecord(raw) ? raw : {};

const maxUtterances =

typeof config.maxUtterances === "number" && Number.isFinite(config.maxUtterances)

? Math.max(1, Math.min(10_000, Math.floor(config.maxUtterances)))

// oxlint-disable-next-line typescript/no-unnecessary-type-parameters -- JSON parsing helper lets callers ascribe the expected payload type.

export function safeParseJson<T>(raw: string): T | null {

try {

// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- JSON parsing helper lets callers ascribe the expected payload type.

return JSON.parse(raw) as T;

} catch {

return null;

agentReactionGuidance?: "minimal" | "extensive";

};

const LEVELS = new Set<ReactionLevel>(["off", "ack", "minimal", "extensive"]);

function parseLevel(

value: unknown,

): { kind: "missing" } | { kind: "invalid" } | { kind: "ok"; value: ReactionLevel } {

if (!trimmed) {

return { kind: "missing" };

}

if (LEVELS.has(trimmed as ReactionLevel)) {

return { kind: "ok", value: trimmed as ReactionLevel };

switch (trimmed) {

case "off":

case "ack":

case "minimal":

case "extensive":

return { kind: "ok", value: trimmed };

}

return { kind: "invalid" };

}