Strasmore Research
Market Recap Matt ConnorBy Matt Connor · Updated 2026-07-08

Market Recap: July 6, 2026 — The Day in Numbers

Back from the Independence Day break: a growth-led gap up, the memory rout half-reversed, a mirror-image megacap rotation, and a wall of reverse splits.

Monday, July 6, 2026 — the first session back from the Independence Day weekend — opened with a growth-led gap up and held it. QQQ closed 1.39% against DIA's 0.42%, the mirror of Thursday's rotation, and breadth ran green: 3861 liquid names rose against 2242 — 62.4% of the tape. Most of the index move arrived as the reopening gap, not the intraday grind. Every number below is read from a stored query — expand any panel for the exact SQL.

The scoreboard

Every change compares July 6's last regular-session minute bar with Thursday July 2's — three calendar days and one market holiday back.

QuerySPY / QQQ / DIA / IWM — July 6 vs the July 2 close, regular hours
The exact SQL behind every number
WITH prior AS (
    SELECT ticker, argMax(close, window_start) AS prior_close
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker IN ('SPY', 'QQQ', 'DIA', 'IWM')
      AND window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 20:00:00'
    GROUP BY ticker
),
sess AS (
    SELECT ticker,
           argMin(open, window_start) AS day_open,
           argMax(close, window_start) AS day_close,
           max(high) AS day_high,
           min(low) AS day_low,
           round(toFloat64(sum(volume)) / 1e6, 1) AS shares_traded_m
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker IN ('SPY', 'QQQ', 'DIA', 'IWM')
      AND window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00'
    GROUP BY ticker
)
SELECT
    s.ticker AS ticker,
    round(toFloat64(p.prior_close), 2) AS prior_close,
    round(toFloat64(s.day_open), 2) AS day_open,
    round(toFloat64(s.day_close), 2) AS day_close,
    round((toFloat64(s.day_open) / toFloat64(p.prior_close) - 1) * 100, 2) AS gap_pct,
    round((toFloat64(s.day_close) / toFloat64(s.day_open) - 1) * 100, 2) AS intraday_pct,
    round((toFloat64(s.day_close) / toFloat64(p.prior_close) - 1) * 100, 2) AS pct_change,
    round(toFloat64(s.day_high), 2) AS day_high,
    round(toFloat64(s.day_low), 2) AS day_low,
    s.shares_traded_m AS shares_traded_m
FROM sess s
JOIN prior p ON s.ticker = p.ticker
ORDER BY s.ticker

QQQ's 1.39% led the four index ETFs and DIA's 0.42% trailed — growth over industrials, the exact inverse of Thursday, when DIA rose and QQQ fell. SPY closed 0.87%, IWM 0.45%. The split between gap and grind is the day's real shape: QQQ opened 1.01% above Thursday's close and added only 0.38% more from open to close, and SPY's 0.53% gap likewise carried most of its 0.87% day. The small-cap and industrial ETFs barely gapped (0.07% for IWM, 0.17% for DIA) and ground higher inside the session instead.

Was the day unusual?

QuerySPY's open-to-close move ranked against the trailing month of sessions (rank 1 = biggest absolute move)
The exact SQL behind every number
SELECT round(anyIf(oc_pct, d = toDate('2026-07-06')), 2) AS day_move_pct,
       arrayCount(x -> x > abs(anyIf(oc_pct, d = toDate('2026-07-06'))), groupArrayIf(abs(oc_pct), d != toDate('2026-07-06'))) + 1 AS abs_move_rank,
       count() AS sessions_compared,
       toString(min(d)) AS first_session
FROM (
    SELECT toDate(toTimeZone(window_start, 'America/New_York')) AS d,
           (argMax(toFloat64(close), window_start) / argMin(toFloat64(open), window_start) - 1) * 100 AS oc_pct
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'SPY'
      AND window_start >= toDateTime('2026-06-06 00:00:00')
      AND window_start < toDateTime('2026-07-07 00:00:00')
      AND (toHour(window_start) * 60 + toMinute(window_start)) BETWEEN 810 AND 1199
    GROUP BY d
)

At the index level, no: SPY's open-to-close move of 0.34% ranks 13 of 19 trailing sessions by absolute size — mid-pack (open-to-close within the session, a different lens from the scoreboard's close-over-close). The intraday tape was ordinary; the overnight gap is where the day happened, and single names are where it was loud.

Breadth: green tape, growth back in front

QueryAdvancers vs decliners among tickers with at least $1M traded on July 6
The exact SQL behind every number
WITH per_ticker AS (
    SELECT
        ticker,
        toFloat64(argMaxIf(close, window_start, window_start < '2026-07-06 00:00:00')) AS prior_close,
        toFloat64(argMaxIf(close, window_start, window_start >= '2026-07-06 00:00:00')) AS day_close,
        sumIf(toFloat64(close) * toFloat64(volume), window_start >= '2026-07-06 00:00:00') AS day_dollar_volume
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE (window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 20:00:00')
       OR (window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00')
    GROUP BY ticker
)
SELECT
    countIf(day_close > prior_close AND day_dollar_volume >= 1000000) AS advancers,
    countIf(day_close < prior_close AND day_dollar_volume >= 1000000) AS decliners,
    countIf(day_close = prior_close AND day_dollar_volume >= 1000000) AS unchanged,
    countIf(day_dollar_volume >= 1000000) AS liquid_tickers,
    count() AS tickers_traded_both_sessions,
    count() - countIf(day_dollar_volume >= 1000000) AS dropped_by_liquidity_filter,
    round(100.0 * countIf(day_close > prior_close AND day_dollar_volume >= 1000000)
        / countIf(day_dollar_volume >= 1000000), 1) AS advancer_pct
FROM per_ticker
WHERE prior_close > 0 AND day_close > 0

3861 advancers, 2242 decliners, 86 unchanged — 62.4% of the liquid tape rose. Index weighting and equal-count breadth agreed on July 6, both green, where Thursday split them. The filter drops 5361 of 11550 dual-session tickers under $1 million traded, counted here.

The day's highlight: the memory rout, half-reversed

The memory-and-storage complex that broke across Wednesday and Thursday bounced Monday — but only half of it. Co-movement and magnitude reported; the data does not say why.

QueryThe memory and storage names: change vs Thursday's close, range timing, and dollar volume
The exact SQL behind every number
WITH per_name AS (
    SELECT
        ticker,
        toFloat64(argMaxIf(close, window_start, window_start < '2026-07-06 00:00:00')) AS prior_close,
        toFloat64(argMaxIf(close, window_start, window_start >= '2026-07-06 00:00:00')) AS day_close,
        maxIf(toFloat64(high), window_start >= '2026-07-06 00:00:00') AS day_high,
        minIf(toFloat64(low), window_start >= '2026-07-06 00:00:00') AS day_low,
        argMinIf(window_start, toFloat64(low), window_start >= '2026-07-06 00:00:00') AS low_bar,
        argMaxIf(window_start, toFloat64(high), window_start >= '2026-07-06 00:00:00') AS high_bar,
        round(sumIf(toFloat64(close) * toFloat64(volume), window_start >= '2026-07-06 00:00:00') / 1e9, 2) AS day_dollar_bn
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker IN ('MU', 'SNDK', 'STX', 'WDC')
      AND ((window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 20:00:00')
        OR (window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00'))
    GROUP BY ticker
)
SELECT
    ticker,
    round(prior_close, 2) AS prior_close,
    round(day_close, 2) AS day_close,
    round((day_close / prior_close - 1) * 100, 2) AS pct_chg,
    round(day_high, 2) AS day_high,
    formatDateTime(toTimeZone(high_bar, 'America/New_York'), '%H:%i') AS day_high_et,
    round(day_low, 2) AS day_low,
    formatDateTime(toTimeZone(low_bar, 'America/New_York'), '%H:%i') AS day_low_et,
    round((day_high / day_low - 1) * 100, 2) AS range_pct,
    day_dollar_bn
FROM per_name
ORDER BY ticker

The two drive makers led the rebound: Western Digital 7.14% and Seagate 6%, both topping out mid-morning (10:44 and 10:39 ET). The two heaviest names sat it out: MU added just 0.88% and printed its low at 15:59 — the closing bar — while SanDisk finished -0.03%, flat on the day across a 7.27% high-to-low range. MU still moved $30.9 billion of stock, more than the other three combined; the quarter these names led is in the MU deep-dive.

The rotation's other half, inside the megacaps:

QueryMegacap rotation: change vs Thursday's close, range timing, and dollar volume
The exact SQL behind every number
WITH per_name AS (
    SELECT
        ticker,
        toFloat64(argMaxIf(close, window_start, window_start < '2026-07-06 00:00:00')) AS prior_close,
        toFloat64(argMaxIf(close, window_start, window_start >= '2026-07-06 00:00:00')) AS day_close,
        maxIf(toFloat64(high), window_start >= '2026-07-06 00:00:00') AS day_high,
        minIf(toFloat64(low), window_start >= '2026-07-06 00:00:00') AS day_low,
        argMinIf(window_start, toFloat64(low), window_start >= '2026-07-06 00:00:00') AS low_bar,
        argMaxIf(window_start, toFloat64(high), window_start >= '2026-07-06 00:00:00') AS high_bar,
        round(sumIf(toFloat64(close) * toFloat64(volume), window_start >= '2026-07-06 00:00:00') / 1e9, 2) AS day_dollar_bn
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker IN ('AAPL', 'MSFT', 'NVDA', 'TSLA')
      AND ((window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 20:00:00')
        OR (window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00'))
    GROUP BY ticker
)
SELECT
    ticker,
    round(prior_close, 2) AS prior_close,
    round(day_close, 2) AS day_close,
    round((day_close / prior_close - 1) * 100, 2) AS pct_chg,
    round(day_high, 2) AS day_high,
    formatDateTime(toTimeZone(high_bar, 'America/New_York'), '%H:%i') AS day_high_et,
    round(day_low, 2) AS day_low,
    formatDateTime(toTimeZone(low_bar, 'America/New_York'), '%H:%i') AS day_low_et,
    round((day_high / day_low - 1) * 100, 2) AS range_pct,
    day_dollar_bn
FROM per_name
ORDER BY ticker

TSLA ran a one-way climb to 6.86% — low at 09:37 ET near the open, high at 15:59 (the closing bar) — the mirror of its Thursday fall. AAPL added 1.49% and NVDA 0.57%, while MSFT was the lone red megacap at -0.7%, its high printed at the 09:30 open before it faded. Same four names, opposite day.

Where the money traded

QueryVolume leaders two ways: top 6 by dollars traded, top 4 by shares traded (one reused-symbol listing excluded pending entity verification)
The exact SQL behind every number
SELECT leaderboard, ticker, dollar_volume_bn, shares_m,
    round(100 * if(leaderboard = 'by dollars traded', dollar_volume_bn, shares_m)
        / max(if(leaderboard = 'by dollars traded', dollar_volume_bn, shares_m)) OVER (PARTITION BY leaderboard), 1) AS pct_of_board_leader
FROM (
    SELECT
        'by dollars traded' AS leaderboard,
        ticker,
        round(sum(toFloat64(close) * toFloat64(volume)) / 1e9, 2) AS dollar_volume_bn,
        round(sum(toFloat64(volume)) / 1e6, 1) AS shares_m
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00'
      AND ticker NOT IN ('SPCX')
    GROUP BY ticker
    ORDER BY dollar_volume_bn DESC
    LIMIT 6
    UNION ALL
    SELECT
        'by shares traded' AS leaderboard,
        ticker,
        round(sum(toFloat64(close) * toFloat64(volume)) / 1e9, 2) AS dollar_volume_bn,
        round(sum(toFloat64(volume)) / 1e6, 1) AS shares_m
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00'
      AND ticker NOT IN ('SPCX')
    GROUP BY ticker
    ORDER BY shares_m DESC
    LIMIT 4
)
ORDER BY leaderboard ASC, if(leaderboard = 'by dollars traded', dollar_volume_bn, shares_m) DESC

SPY led the dollar tape at $31.49 billion, with MU ($30.9 billion) a step behind — ending MU's four-session run at the top (Monday through Thursday carry the receipts), its turnover roughly a third off the ~$50 billion it ran on Thursday. On the share board, SOXS — the 3x-inverse semiconductor ETF — traded 467.1 million shares, topping the count again even as the chips it tracks rose (Thursday's board carries the prior print). Basis: July 6 regular hours; one reused-symbol listing is excluded pending entity verification — its receipts.

QueryShares traded per 30-minute bucket, regular hours (billions)
The exact SQL behind every number
SELECT
    formatDateTime(toStartOfInterval(toTimeZone(window_start, 'America/New_York'), INTERVAL 30 MINUTE), '%H:%i') AS et_time,
    round(sum(toFloat64(volume)) / 1e9, 2) AS shares_bn,
    round(100 * sum(toFloat64(volume)) / max(sum(toFloat64(volume))) OVER (), 1) AS pct_of_biggest_bucket
FROM global_markets.delayed_stocks_minute_aggs
WHERE window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00'
GROUP BY et_time
ORDER BY et_time

1.96 billion shares in the opening half hour, a 0.68 billion trough at 14:30, and 2.1 billion into the 15:30 close — the ordinary intraday smile, heaviest at both ends.

The options tape

QueryOne row for the whole options day: volume, call share, and the Monday same-day expiry
The exact SQL behind every number
WITH
    (
        SELECT (any(underlying_symbol), any(toFloat64(strike_price)), any(option_type),
                any(toDateOrNull(concat('20', substring(ticker, length(ticker) - 14, 6)))),
                sum(size), count(), round(avg(toFloat64(price)), 3))
        FROM global_markets.options_trades
        WHERE sip_timestamp >= '2026-07-06 00:00:00' AND sip_timestamp < '2026-07-07 00:00:00'
        GROUP BY ticker
        ORDER BY sum(size) DESC
        LIMIT 1
    ) AS top_contract,
    (
        SELECT round(toFloat64(argMax(close, window_start)), 2)
        FROM global_markets.delayed_stocks_minute_aggs
        WHERE ticker = 'SPY' AND window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00'
    ) AS spy_regular_close
SELECT
    round(count() / 1e6, 2) AS option_prints_m,
    round(toFloat64(sum(size)) / 1e6, 2) AS contracts_m,
    round(100.0 * sumIf(size, option_type = 'C') / sum(size), 1) AS call_pct_of_volume,
    round(100.0 * sumIf(size, substring(ticker, length(ticker) - 14, 6) = '260706') / sum(size), 1) AS same_day_expiry_pct,
    round(toFloat64(sumIf(size, substring(ticker, length(ticker) - 14, 6) = '260706')) / 1e6, 2) AS same_day_contracts_m,
    round(toFloat64(sumIf(size, underlying_symbol = 'SPY')) / 1e6, 2) AS spy_contracts_m,
    round(toFloat64(sumIf(size, underlying_symbol = 'QQQ')) / 1e6, 2) AS qqq_contracts_m,
    round(toFloat64(sumIf(size, underlying_symbol = 'TSLA')) / 1e6, 2) AS tsla_contracts_m,
    top_contract.1 AS top_contract_underlying,
    top_contract.2 AS top_contract_strike,
    top_contract.3 AS top_contract_type,
    if(top_contract.3 = 'C', 1, 0) AS top_contract_is_call,
    top_contract.4 AS top_contract_expiry,
    top_contract.5 AS top_contract_volume,
    round(top_contract.7, 3) AS top_contract_avg_price,
    round(spy_regular_close - top_contract.2, 2) AS spy_close_minus_strike
FROM global_markets.options_trades
WHERE sip_timestamp >= '2026-07-06 00:00:00' AND sip_timestamp < '2026-07-07 00:00:00'

Options traded 60.98 million contracts across 10.53 million prints, 58.4% of the volume in calls. Same-day expiries took 38.7% of the tape (23.57 million contracts) — a routine Monday 0DTE share, well below Thursday's double-loaded holiday-eve figure. The busiest single contract was the same-day SPY $751 call — 1082297 contracts at an average $0.564 — with SPY closing $0.3 above the strike, so it expired in the money. A call atop the board, where Thursday had finished on a put.

Rates: a quiet curve over the long weekend

QueryThe treasury curve: July 6 vs the July 2 print (populated maturities only)
The exact SQL behind every number
SELECT
    t.1 AS curve_point,
    round(t.2, 2) AS jul6_yield_pct,
    round((t.2 - t.3) * 100) AS session_change_bp
FROM (
    SELECT arrayJoin([
        ('1 month',  toFloat64(d.yield_1_month),  toFloat64(p.yield_1_month)),
        ('3 month',  toFloat64(d.yield_3_month),  toFloat64(p.yield_3_month)),
        ('1 year',   toFloat64(d.yield_1_year),   toFloat64(p.yield_1_year)),
        ('2 year',   toFloat64(d.yield_2_year),   toFloat64(p.yield_2_year)),
        ('5 year',   toFloat64(d.yield_5_year),   toFloat64(p.yield_5_year)),
        ('10 year',  toFloat64(d.yield_10_year),  toFloat64(p.yield_10_year)),
        ('30 year',  toFloat64(d.yield_30_year),  toFloat64(p.yield_30_year)),
        ('2s10s spread', toFloat64(d.yield_10_year - d.yield_2_year), toFloat64(p.yield_10_year - p.yield_2_year))
    ]) AS t
    FROM (SELECT * FROM global_markets.treasury_yields WHERE date = '2026-07-06') AS d,
         (SELECT * FROM global_markets.treasury_yields WHERE date = '2026-07-02') AS p
)

The curve barely moved over the long weekend. The 10-year sat at 4.48% and the 2s10s spread at 0.35 percentage points, both within a basis point or two of the July 2 print; the 3-month was the only mover of note at 5 basis points. Changes compare July 6 with July 2 — consecutive trading sessions across the holiday.

The calendar behind the day

QueryJuly 6's corporate calendar and information flow, in one row (including the reverse-split wall behind a screener trap)
The exact SQL behind every number
WITH
    (
        SELECT (count(), uniqExact(publisher))
        FROM global_markets.stocks_news
        WHERE toDate(toTimeZone(published_utc, 'America/New_York')) = '2026-07-06'
    ) AS news,
    (
        SELECT (argMax(t, n), max(n))
        FROM (
            SELECT t, count() AS n
            FROM (
                SELECT arrayJoin(tickers) AS t
                FROM global_markets.stocks_news
                WHERE toDate(toTimeZone(published_utc, 'America/New_York')) = '2026-07-06'
            )
            WHERE t != 'SPCX'
            GROUP BY t
        )
    ) AS top_news
SELECT
    (SELECT count() FROM global_markets.stocks_dividends WHERE ex_dividend_date = '2026-07-06') AS ex_dividend_records,
    (SELECT count() FROM global_markets.stocks_splits WHERE execution_date = '2026-07-06') AS splits_executed,
    (SELECT countIf(toFloat64(split_from) > toFloat64(split_to)) FROM global_markets.stocks_splits WHERE execution_date = '2026-07-06') AS reverse_splits,
    (SELECT countIf(toFloat64(split_to) > toFloat64(split_from)) FROM global_markets.stocks_splits WHERE execution_date = '2026-07-06') AS forward_splits,
    (SELECT count() FROM global_markets.stocks_ipos WHERE listing_date = '2026-07-06') AS ipos_listed,
    (SELECT uniqExact(accession_number) FROM global_markets.stocks_sec_edgar_index WHERE filing_date = '2026-07-06') AS sec_filings,
    (SELECT uniqExactIf(accession_number, form_type = '4') FROM global_markets.stocks_sec_edgar_index WHERE filing_date = '2026-07-06') AS insider_form4_filings,
    (SELECT uniqExactIf(accession_number, form_type = '8-K') FROM global_markets.stocks_sec_edgar_index WHERE filing_date = '2026-07-06') AS filings_8k,
    news.1 AS news_articles,
    news.2 AS news_publishers,
    top_news.1 AS most_covered_ticker,
    top_news.2 AS most_covered_articles,
    (SELECT any(toFloat64(split_from)) FROM global_markets.stocks_splits WHERE ticker = 'TXXS' AND execution_date = '2026-07-06') AS txxs_split_from,
    (SELECT any(toFloat64(split_to)) FROM global_markets.stocks_splits WHERE ticker = 'TXXS' AND execution_date = '2026-07-06') AS txxs_split_to,
    (SELECT round(toFloat64(argMax(close, window_start)), 2) FROM global_markets.delayed_stocks_minute_aggs
     WHERE ticker = 'TXXS' AND window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 20:00:00') AS txxs_prev_close,
    (SELECT round(toFloat64(argMax(close, window_start)), 2) FROM global_markets.delayed_stocks_minute_aggs
     WHERE ticker = 'TXXS' AND window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00') AS txxs_day_close

118 dividend records went ex-dividend, 14 splits executed, 0 new listings arrived, and the SEC index logged 3144 filings — 1219 Form 4s, 201 8-Ks — a lighter book than the pre-holiday Thursday. Our news feed carried 236 articles; the most-covered name was NVDA at 25 articles.

The splits were the inverse of Thursday's: 13 of the 14 were reverse splits — share consolidations at sub-dollar prices — against 1 forward. A reverse split turns many old shares into one new share at a proportionally higher price, so the unadjusted tape shows a fake triple-digit "gain." TXXS is the clean example: a 10-for-1 reverse split carried its unadjusted close from $2.35 on Thursday to $24.34 Monday — ten old shares becoming one, not a tenfold rally. Every mover screen behind this page excludes splits for exactly that reason; Thursday's CRWD forward split faked the opposite, a crash.

The session, verified — the first back from the break

QuerySession check: SPY's observed minute-bar span, the July 3 closure, and the next one on the calendar
The exact SQL behind every number
SELECT
    formatDateTime(min(toTimeZone(window_start, 'America/New_York')), '%H:%i') AS first_spy_bar_et,
    formatDateTime(max(toTimeZone(window_start, 'America/New_York')), '%H:%i') AS last_spy_bar_et,
    count() AS spy_minute_bars,
    countIf(window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00') AS regular_session_bars,
    uniqExactIf(toDate(toTimeZone(window_start, 'America/New_York')), window_start >= '2026-07-06 13:30:00' AND window_start < '2026-07-06 20:00:00') AS day_sessions,
    (SELECT count() FROM global_markets.delayed_stocks_minute_aggs
     WHERE ticker = 'SPY' AND window_start >= '2026-07-03 00:00:00' AND window_start < '2026-07-04 00:00:00') AS jul3_spy_bars,
    (SELECT toString(min(date)) FROM global_markets.stocks_market_holidays WHERE date > '2026-07-06' AND status = 'closed') AS next_closure_date,
    (SELECT argMin(name, date) FROM global_markets.stocks_market_holidays WHERE date > '2026-07-06' AND status = 'closed') AS next_closure_name
FROM global_markets.delayed_stocks_minute_aggs
WHERE ticker = 'SPY' AND window_start >= '2026-07-06 00:00:00' AND window_start < '2026-07-07 00:00:00'

July 6 was a full session, not an early close: SPY's bars run 04:00 to 19:59 New York time with exactly 390 regular-window bars. The Friday before, July 3, printed 0 SPY bars — a full closure for Independence Day, July 4 falling on a Saturday — so Monday was the first session back across a three-day weekend. The next scheduled closure is Labor Day, 2026-09-07. The four-session holiday week before it is measured end to end in the week recap.

Data notes

  • Dollar volume is a per-minute proxy — close × volume summed per minute bar.
  • The gap-versus-grind split is measured from each ETF's first regular-session bar (the open) against the prior session's last regular close; the remainder is open-to-close inside July 6.
  • Reverse-split "gains" are unadjusted-tape artifacts — receipted inline (TXXS) and excluded from every mover screen behind this page.
  • The index ETFs' highs and lows were cross-checked against adjacent bars at authoring time — an editorial procedure, receipted only when it surfaces an anomaly; none did on this session.
  • One reused-symbol listing is excluded from the volume leaderboards pending entity verification; its own post carries the receipts.

Methodology

  • The period is a single trading session ({v:session_count} session, verified from observed bars). Timestamps are stored in UTC and converted to New York time inside the queries. "Close" means the last regular-session minute bar; day changes compare July 6 with July 2, the prior session across the July 3 closure. The session and the July 3 closure were verified from observed bars — never assumed (the exchange-calendar dataset only carries upcoming closures, here Labor Day).
  • Decimal columns are cast to 64-bit floats before ratio arithmetic; option expiries are re-parsed from the OCC ticker (the table's own expiry column is broken). All panels are read once, at authoring time, through the gated read-only path. Warehouse state as of July 7, 2026.

Every panel is a stored query result — chart, table, and SQL are one object. Paste any of them into the Strasmore terminal and make them your own. Previous session: July 2. The week before the break: the four-session holiday week.

#recap#daily#spy#qqq#market structure