Function propagateInternalVisibility

scripts/codegen/utils.ts:822–890

(schema: JSONSchema7)

 * Mutates `schema` in place and returns it. Idempotent.
 */
export function propagateInternalVisibility(schema: JSONSchema7): JSONSchema7 {
    if (typeof schema !== "object" || schema === null) return schema;

    const { definitions, $defs } = collectDefinitionCollections(schema as Record<string, unknown>);
    const allDefs: Record<string, JSONSchema7Definition> = { ...definitions, ...$defs };
    const internalTypeNames = new Set<string>();
    for (const [name, def] of Object.entries(allDefs)) {
        if (def && typeof def === "object" && isSchemaInternal(def as JSONSchema7)) {
            internalTypeNames.add(name);
        }
    }
    if (internalTypeNames.size === 0) return schema;

    const refToName = (ref: unknown): string | undefined => {
        if (typeof ref !== "string") return undefined;
        const m = ref.match(/^#\/(?:definitions|\$defs)\/([^/]+)$/);
        return m ? m[1] : undefined;
    };

    /** Returns true when a property's *direct* type carrier is an internal definition. */
    const propertyReferencesInternal = (propSchema: JSONSchema7): boolean => {
        const direct = refToName((propSchema as Record<string, unknown>).$ref);
        if (direct && internalTypeNames.has(direct)) return true;
        const items = (propSchema as Record<string, unknown>).items;
        if (items && typeof items === "object" && !Array.isArray(items)) {
            const itemsRef = refToName((items as Record<string, unknown>).$ref);
            if (itemsRef && internalTypeNames.has(itemsRef)) return true;
        }
        const addl = (propSchema as Record<string, unknown>).additionalProperties;
        if (addl && typeof addl === "object") {
            const addlRef = refToName((addl as Record<string, unknown>).$ref);
            if (addlRef && internalTypeNames.has(addlRef)) return true;
        }
        return false;
    };

    const visit = (node: unknown): void => {
        if (!node || typeof node !== "object") return;
        if (Array.isArray(node)) {
            for (const item of node) visit(item);
            return;
        }
        const record = node as Record<string, unknown>;
        const props = record.properties;
        if (props && typeof props === "object" && !Array.isArray(props)) {
            for (const propSchema of Object.values(props as Record<string, unknown>)) {
                if (!propSchema || typeof propSchema !== "object") continue;
                if (!isSchemaInternal(propSchema as JSONSchema7) && propertyReferencesInternal(propSchema as JSONSchema7)) {
                    (propSchema as Record<string, unknown>).visibility = "internal";
                }
                visit(propSchema);
            }
        }
        for (const key of ["items", "additionalProperties", "anyOf", "allOf", "oneOf"]) {
            if (record[key]) visit(record[key]);
        }
        for (const collectionKey of ["definitions", "$defs"]) {
            const collection = record[collectionKey];