Type popping out of text frame

I've made an attempt! I have written a script (that uses my earlier function to detect protruding glyphs) and makes an adjustment to the entire story's text—I just scaled the text horizontally because that was quickest—so that no glyph protrudes form the story's text frame(s).

No idea if this is suitable for real use, but it might be a starting point for a script to fix the mistake without re-flowing everything.

- Mark

/**
 * @File Fix Protruding Story.js
 *
 * Usage:
 *   1. Select a text frame.
 *   2. Run script.
 *
 * Notes:
 *   - Adjusts entire story, not only selected text frame.
 *   - Adds left/right text inset as needed to stop glyphs
 *     protruding from the text frame(s).
 *   - Does not make attempt at vertical axis protrusions.
 *   - Adjusts a story by slight horizontal scaling,
 *     so that no glyph protrudes from the story's
 *     text frame(s). (A better implementations might
 *     adjust tracking, for example.)
 *   - Every text frame containing story will be given
 *     identical text insets, even if no glyphs protrude
 *     from a particular text frame; this is to avoid the
 *     margin jumping around in a book.
 *   - The left and right text insets may be different.
 *   - Quick, proof-of-concept only!
 *
 * @7111211 m1b
 * @version 2024-08-12
 * @discussion https://community.adobe.com/t5/indesign-discussions/type-popping-out-of-text-frame/m-p/13711048
 */
function main() {

    var doc = app.activeDocument,
        textFrame = doc.selection[0];

    if (
        !textFrame
        || !textFrame.isValid
        || textFrame.constructor.name !== 'TextFrame'
    ) {
        alert('Please select a text frame and try again.');
        return;
    }

    app.scriptPreferences.measurementUnit = MeasurementUnits.POINTS;

    // get all text frames containing story
    var story = textFrame.parentStory,
        textFrames = story.textContainers;

    // calculate the maximum overshoot distance on all sides of all frames
    var overTop = 0,
        overLeft = 0,
        overBottom = 0,
        overRight = 0;

    for (var i = textFrames.length - 1, frame, bounds, protrusions, over; i >= 0; i--) {

        frame = textFrames[i];
        protrusions = getProtrudingCharacterBounds(frame);

        if (!protrusions)
            return;

        over = combineBounds(protrusions);
        bounds = frame.geometricBounds;

        overTop = Math.max(overTop, bounds[0] - over[0]);
        overLeft = Math.max(overLeft, bounds[1] - over[1]);
        overBottom = Math.max(overBottom, over[1] - bounds[2]);
        overRight = Math.max(overRight, over[3] - bounds[3]);

    }

    // adjust each text frame insets so no overshoot
    for (var i = textFrames.length - 1, frame, scale; i >= 0; i--) {

        frame = textFrames[i];

        frame.textFramePreferences.insetSpacing = [
            frame.textFramePreferences.insetSpacing[0],
            frame.textFramePreferences.insetSpacing[1] + overLeft,
            frame.textFramePreferences.insetSpacing[2],
            frame.textFramePreferences.insetSpacing[3] + overRight
        ];

        // quick and dirty solution:
        // horizontal scale text to fit
        scale = (bounds[3] - bounds[1] - overLeft - overRight) / (bounds[3] - bounds[1]);
        frame.textStyleRanges.everyItem().horizontalScale *= scale;

    }

};
app.doScript(main, ScriptLanguage.JAVASCRIPT, undefined, UndoModes.ENTIRE_SCRIPT, 'Fix Protruding Story');

/**
 * Returns bounds of the protruding
 * parts of lines of text frame.
 *
 * Known limitation: because it duplicates the text frame,
 * this will sometimes cause a reflow if a paragraph using
 * a multi-line composer spans multiple text frames.
 *
 * @7111211 m1b
 * @version 2024-04-11
 * @9397041 {TextFrame} tf - an Indesign TextFrame.
 * @9397041 {Number} [offset] - distance, in points, to enlarge each bounds by (default: 0).
 * @Returns {Array<Array>} - array of [T, L, B, R] arrays.
 */
function getProtrudingCharacterBounds(tf, offset) {

    app.scriptPreferences.measurementUnit = MeasurementUnits.POINTS;
    offset = offset || 0;

    // get the outermost textframe
    while (tf.parent.constructor.name == 'Character')
        tf = tf.parent.parentTextFrames[0];

    var bounds = tf.geometricBounds;

    // duplicate text frame
    var dup = tf.duplicate();
    outlines = dup.createOutlines();

    // add outlines of anchored text frames
    while (outlines[outlines.length - 1].textFrames.length > 0)
        outlines.push(outlines[outlines.length - 1].textFrames[0].createOutlines()[0]);

    // find the protruding outlines
    var found = [];

    outlinesLoop:
    for (var i = 0; i < outlines.length; i++) {

        var polygons;
        if (outlines[i].constructor.name == 'Polygon')
            // we get a Polygon if there is only one character in text frame
            polygons = [outlines[i]];

        else if (outlines[i].hasOwnProperty('polygons'))
            // a Group with polygons
            polygons = outlines[i].polygons;

        else
            continue;

        for (var j = 0; j < polygons.length; j++) {

            var r = getProtrudingRect(bounds, polygons[j].visibleBounds, offset);

            if (r)
                found = found.concat(r);

        }

    }

    // delete all the outlines
    for (var i = outlines.length - 1; i >= 0; i--)
        outlines[i].remove();

    if (dup.isValid)
        // sometimes the duplicate is left behind
        // eg. when there is a table in the text frame
        dup.remove();

    if (found)
        return found;

};

/**
 * Returns the protruding part of a rectangle.
 * @7111211 m1b
 * @version 2024-04-11
 * @9397041 {Array<Number>} r1 - [T,L,B,R].
 * @9397041 {Array<Number>} r2 - [T,L,B,R].
 * @9397041 {Number} [offset] - the amount to expand resulting rectangle (default: 0).
 * @Returns {Array<Number>} [T,L,B,R].
 */
function getProtrudingRect(r1, r2, offset) {

    offset = offset || 0;

    var results = [];

    var top1 = r1[0], top2 = r2[0],
        left1 = r1[1], left2 = r2[1],
        bottom1 = r1[2], bottom2 = r2[2],
        right1 = r1[3], right2 = r2[3];

    if (
        bottom1 <= top2 || top1 >= bottom2 || right1 <= left2 || left1 >= right2
        || (left2 >= left1 && right2 <= right1 && top2 >= top1 && bottom2 <= bottom1)
    ) {
        // No overlap between the rectangles, or second
        // rectangle is completely within the first.
        return;
    }

    // handle cases where protrudes from both sides
    if (top1 > top2 && bottom1 < bottom2) {
        results = results.concat(getProtrudingRect([top1, left1, bottom2, right1], r2, offset));
        results = results.concat(getProtrudingRect([top2, left1, bottom1, right1], r2, offset));
        return results;
    }

    if (left1 > left2 && right1 < right2) {
        results = results.concat(getProtrudingRect([top1, left1, bottom1, right2], r2, offset));
        results = results.concat(getProtrudingRect([top1, left2, bottom1, right1], r2, offset));
        return results;
    }

    // Define the outside rectangle.
    var outside = [top2, left2, bottom2, right2];

    // Check for overlap on each side and adjust the outside rectangle accordingly.
    if (left1 > left2) {
        outside[1] = left2;
        outside[3] = left1;
    }
    if (right1 < right2) {
        outside[1] = right1;
        outside[3] = right2;
    }
    if (top1 > top2) {
        outside[0] = top2;
        outside[2] = top1;
    }
    if (bottom1 < bottom2) {
        outside[0] = bottom1;
        outside[2] = bottom2;
    }

    if (offset) {
        // expand by offset (useful for better
        // visibility of tiny protrusions)
        outside[0] -= offset;
        outside[1] -= offset;
        outside[2] += offset;
        outside[3] += offset;
    }

    return [outside];

};


/**
 * Returns the combined bounds of all bounds supplied.
 * Works with Illustrator or Indesign bounds.
 * @7111211 m1b
 * @version 2024-03-09
 * @9397041 {Array<bounds>} boundsArray - an array of bounds [L, T, R, B] or [T, L , B, R].
 * @Returns {bounds} - the combine bounds.
 */
function combineBounds(boundsArray) {

    var combinedBounds = boundsArray[0].slice(),
        comparator;

    if (/indesign/i.test(app.name))
        comparator = [Math.min, Math.min, Math.max, Math.max];
    else if (/illustrator/i.test(app.name))
        comparator = [Math.min, Math.max, Math.max, Math.min];

    for (var i = 1; i < boundsArray.length; i++) {
        var bounds = boundsArray[i];

        combinedBounds[0] = comparator[0](combinedBounds[0], bounds[0]);
        combinedBounds[1] = comparator[1](combinedBounds[1], bounds[1]);
        combinedBounds[2] = comparator[2](combinedBounds[2], bounds[2]);
        combinedBounds[3] = comparator[3](combinedBounds[3], bounds[3]);

    }

    return combinedBounds;

};

Yes it's good. 
Would like it to duplicate the frame to a new layer and put all the markers on that new layer.

It would be simple layer deletion to remove all the other pieces around it.