Strasmore Research
Market Recap 2026-07-03

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

Holiday-eve rotation: positive breadth under a falling Nasdaq, memory-rout day two, a double-loaded Thursday expiry, and the split that faked a crash.

Thursday, July 2, 2026 — the last session before the Independence Day closure — was a rotation day wearing a selloff's headline. QQQ printed -1.71% while DIA rose 1.04%, and breadth was POSITIVE: 3397 liquid names rose against 2758 — 54.6% of the tape green on a day the growth index dropped. The selling was concentrated, not broad, and most of it ran through the same memory complex that broke the day before. Every number below is read from a stored query — expand any panel for the exact SQL.

The scoreboard

Every change compares July 2's last regular-session minute bar with Wednesday July 1's.

QuerySPY / QQQ / DIA / IWM — July 2 vs the July 1 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-01 13:30:00' AND window_start < '2026-07-01 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-02 13:30:00' AND window_start < '2026-07-02 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_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

DIA at 1.04% against QQQ at -1.71% is the day in one line — the price-weighted industrials index and the growth index nearly three points of daily return apart. SPY split the difference at -0.12%; IWM closed -0.59%.

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-02')), 2) AS day_move_pct,
       arrayCount(x -> x > abs(anyIf(oc_pct, d = toDate('2026-07-02'))), groupArrayIf(abs(oc_pct), d != toDate('2026-07-02'))) + 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-02 00:00:00')
      AND window_start < toDateTime('2026-07-03 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.35% ranks 15 of 22 trailing sessions by absolute size — mid-pack (open-to-close within the session, a different lens from the scoreboard's close-over-close, stated here). The single-name tape is where July 2 was loud.

Breadth: green tape, red growth index

QueryAdvancers vs decliners among tickers with at least $1M traded on July 2
The exact SQL behind every number
WITH per_ticker AS (
    SELECT
        ticker,
        toFloat64(argMaxIf(close, window_start, window_start < '2026-07-02 00:00:00')) AS prior_close,
        toFloat64(argMaxIf(close, window_start, window_start >= '2026-07-02 00:00:00')) AS day_close,
        sumIf(toFloat64(close) * toFloat64(volume), window_start >= '2026-07-02 00:00:00') AS day_dollar_volume
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE (window_start >= '2026-07-01 13:30:00' AND window_start < '2026-07-01 20:00:00')
       OR (window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 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

3397 advancers, 2758 decliners, 63 unchanged — 54.6% of the liquid tape rose while QQQ fell. Index weighting and equal-count breadth answered differently on July 2; days like this are why both get a panel. The filter drops 5318 of 11536 dual-session tickers under $1 million traded, counted here.

The day's highlight: memory rout, day two

The complex that broke Wednesday fell harder Thursday — co-movement and magnitude reported; the data does not say why.

QueryThe memory and storage names: change vs Wednesday'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-02 00:00:00')) AS prior_close,
        toFloat64(argMaxIf(close, window_start, window_start >= '2026-07-02 00:00:00')) AS day_close,
        maxIf(toFloat64(high), window_start >= '2026-07-02 00:00:00') AS day_high,
        minIf(toFloat64(low), window_start >= '2026-07-02 00:00:00') AS day_low,
        argMinIf(window_start, toFloat64(low), window_start >= '2026-07-02 00:00:00') AS low_bar,
        argMaxIf(window_start, toFloat64(high), window_start >= '2026-07-02 00:00:00') AS high_bar,
        round(sumIf(toFloat64(close) * toFloat64(volume), window_start >= '2026-07-02 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-01 13:30:00' AND window_start < '2026-07-01 20:00:00')
        OR (window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 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

SanDisk printed -14.32%, Seagate -10.38%, Western Digital -9.92%, and MU -5.57% — on $51.4 billion of MU turnover, roughly one-and-a-half times what SPY traded all day. The timestamps carry the shape: MU and SanDisk printed their lows at 15:26 and 15:26 ET — late-session lows — while Seagate and Western Digital bottomed earlier in the afternoon (14:23, 13:59). Two-day context lives in Wednesday's recap; the quarter these names led is in the MU deep-dive.

The rotation's other half, inside the megacaps:

QueryMegacap rotation: change vs Wednesday'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-02 00:00:00')) AS prior_close,
        toFloat64(argMaxIf(close, window_start, window_start >= '2026-07-02 00:00:00')) AS day_close,
        maxIf(toFloat64(high), window_start >= '2026-07-02 00:00:00') AS day_high,
        minIf(toFloat64(low), window_start >= '2026-07-02 00:00:00') AS day_low,
        argMinIf(window_start, toFloat64(low), window_start >= '2026-07-02 00:00:00') AS low_bar,
        argMaxIf(window_start, toFloat64(high), window_start >= '2026-07-02 00:00:00') AS high_bar,
        round(sumIf(toFloat64(close) * toFloat64(volume), window_start >= '2026-07-02 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-01 13:30:00' AND window_start < '2026-07-01 20:00:00')
        OR (window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 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

AAPL rose 4.75% in a one-way line — low at 09:30 ET (the open), high at 15:57 (three minutes before the close) — while TSLA ran the mirror image, -7.65% with its high at 09:31 and its low at 15:23. MSFT added 1.41%; NVDA closed -1.55%. Same index, opposite days — that is what DIA-up, QQQ-down looks like name by name.

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 ticker, leaderboard, dollar_volume_bn, if(dollar_volume_bn < 1, dollar_volume_m, NULL) AS dollar_value_m, 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(close) * toFloat64(volume)) / 1e6, 0) AS dollar_volume_m,
        round(sum(toFloat64(volume)) / 1e6, 1) AS shares_m
    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'
      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(close) * toFloat64(volume)) / 1e6, 0) AS dollar_volume_m,
        round(sum(toFloat64(volume)) / 1e6, 1) AS shares_m
    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'
      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

MU's $51.4 billion led the whole tape for a fourth straight session (Monday, Tuesday, and Wednesday carry the receipts) — SPY did $32.7 billion — and SanDisk's $26.57 billion put a second memory name in the top four. On the share board, SOXS — the 3x-inverse semiconductor ETF — traded 748.2 million shares, topping the share board again (Wednesday's board carries the prior print). Basis: July 2 regular hours; one reused-symbol June 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-02 13:30:00' AND window_start < '2026-07-02 20:00:00'
GROUP BY et_time
ORDER BY et_time

2.13 billion shares in the opening half hour, a 0.81 billion trough at 14:30, and 2.3 billion into the holiday-eve close.

The options tape: the shifted weekly lands

QueryOne row for the whole options day: volume, same-day expiry, the holiday-shifted week
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-02 00:00:00' AND sip_timestamp < '2026-07-03 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-02 13:30:00' AND window_start < '2026-07-02 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) = '260702') / sum(size), 1) AS same_day_expiry_pct,
    round(toFloat64(sumIf(size, substring(ticker, length(ticker) - 14, 6) = '260702')) / 1e6, 2) AS thu_jul2_expiry_contracts_m,
    countIf(substring(ticker, length(ticker) - 14, 6) = '260703') AS fri_jul3_expiry_prints,
    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,
    top_contract.1 AS top_contract_underlying,
    top_contract.2 AS top_contract_strike,
    top_contract.3 AS top_contract_type,
    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(top_contract.2 - spy_regular_close, 2) AS top_strike_minus_spy_close,
    round(spy_regular_close - top_contract.2, 2) AS spy_close_minus_strike
FROM global_markets.options_trades
WHERE sip_timestamp >= '2026-07-02 00:00:00' AND sip_timestamp < '2026-07-03 00:00:00'

Options traded 80.96 million contracts across 13.15 million prints, and 47.4% of everything that traded expired that same Thursday. That share landed on a session with no Friday expiry available: no contract with a July 3 expiration code printed all day (0 prints), so Thursday's date carried both the ordinary daily expiry and the week's shifted weekly at once. The busiest single contract was the same-day SPY $740 put — 540403 contracts at an average $0.499 premium, SPY's close landing 4.8 dollars above the strike: out of the money, and a put atop a board where Tuesday and Wednesday had calls. Calls still took 58.4% of total volume. The mechanics of holiday-shifted expiries: the holiday explainer.

Rates: the July 2 print wasn't in yet

QueryThe receipt: no July 2 treasury print at generation time (July 1 present)
The exact SQL behind every number
SELECT
    (SELECT count() FROM global_markets.treasury_yields WHERE date = '2026-07-02') AS jul2_rows,
    (SELECT count() FROM global_markets.treasury_yields WHERE date = '2026-07-01') AS jul1_rows

The treasury feed runs a day or two behind the tape: at generation, the July 2 close had 0 rows on file (1 for July 1), so this page makes no claim about July 2 rates — the panel below carries the last complete print, July 1 against June 30, and this post regenerates when the July 2 print lands.

QueryThe last complete curve print: July 1 vs June 30 (populated maturities only)
The exact SQL behind every number
SELECT
    t.1 AS curve_point,
    round(t.2, 2) AS jul1_yield_pct,
    round((t.2 - t.3) * 100) AS one_day_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-01') AS d,
         (SELECT * FROM global_markets.treasury_yields WHERE date = '2026-06-30') AS p
)

As of that print, the 10-year sat at 4.48% and the 2s10s spread at 0.31 percentage points.

The calendar behind the day

QueryJuly 2's corporate calendar and information flow, in one row (including the split behind a fake screener move)
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-02'
    ) 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-02'
            )
            WHERE t != 'SPCX'
            GROUP BY t
        )
    ) AS top_news
SELECT
    (SELECT count() FROM global_markets.stocks_dividends WHERE ex_dividend_date = '2026-07-02') AS ex_dividend_records,
    (SELECT count() FROM global_markets.stocks_splits WHERE execution_date = '2026-07-02') AS splits_executed,
    (SELECT count() FROM global_markets.stocks_ipos WHERE listing_date = '2026-07-02') AS ipos_listed,
    (SELECT uniqExact(accession_number) FROM global_markets.stocks_sec_edgar_index WHERE filing_date = '2026-07-02') AS sec_filings,
    (SELECT uniqExactIf(accession_number, form_type = '4') FROM global_markets.stocks_sec_edgar_index WHERE filing_date = '2026-07-02') AS insider_form4_filings,
    (SELECT uniqExactIf(accession_number, form_type = '8-K') FROM global_markets.stocks_sec_edgar_index WHERE filing_date = '2026-07-02') AS filings_8k,
    (SELECT arrayStringConcat(groupArray(concat(ticker, ' — ', issuer_name)), '; ') FROM (
        SELECT ticker, issuer_name FROM global_markets.stocks_ipos WHERE listing_date = '2026-07-02' ORDER BY ticker
    )) AS ipo_names,
    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(split_from) FROM global_markets.stocks_splits WHERE ticker = 'CRWD' AND execution_date = '2026-07-02') AS crwd_split_from,
    (SELECT any(split_to) FROM global_markets.stocks_splits WHERE ticker = 'CRWD' AND execution_date = '2026-07-02') AS crwd_split_to,
    (SELECT round(toFloat64(argMax(close, window_start)), 2) FROM global_markets.delayed_stocks_minute_aggs
     WHERE ticker = 'CRWD' AND window_start >= '2026-07-01 13:30:00' AND window_start < '2026-07-01 20:00:00') AS crwd_prev_close,
    (SELECT round(toFloat64(argMax(close, window_start)), 2) FROM global_markets.delayed_stocks_minute_aggs
     WHERE ticker = 'CRWD' AND window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 20:00:00') AS crwd_day_close

318 dividend records went ex-dividend, 8 splits executed, 2 new listings arrived (MIACU — Meridian3 Industrials Acquisition Corp.; VIIU — Viking Acquisition Corp. II), and the SEC index logged 5180 filings — 2109 Form 4s, 258 8-Ks — into the holiday. Our news feed carried 201 articles from 3 publishers; the most-covered name was NVDA at 18 articles.

One of those splits is a trap for anyone reading raw closes: CRWD executed a 4-for-1 forward split this session, so the unadjusted tape shows $772.45 on Wednesday and $193.67 on Thursday — a screaming fake decline that is really four new shares for each old one. Every mover screen behind this page excludes it for exactly that reason, and the split receipt is in the panel above.

The session, verified — and the Friday that wasn't

QuerySession check: SPY's observed minute-bar span, and the July 3 closure on the tape
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-02 13:30:00' AND window_start < '2026-07-02 20:00:00') AS regular_session_bars,
    uniqExactIf(toDate(toTimeZone(window_start, 'America/New_York')), window_start >= '2026-07-02 13:30:00' AND window_start < '2026-07-02 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
FROM global_markets.delayed_stocks_minute_aggs
WHERE ticker = 'SPY' AND window_start >= '2026-07-02 00:00:00' AND window_start < '2026-07-03 00:00:00'

July 2 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 next day, Friday July 3, printed 0 SPY bars — measured two days after the fact, past the feed's ingest lag — a full market closure for Independence Day, July 4 falling on a Saturday. The four-session week 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 July 2 treasury print was pending at generation — disclosed inline with a row-count receipt; the post regenerates when it lands.
  • CRWD's raw close change is a split artifact — receipted inline; excluded from mover screens.
  • 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 June 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 2 with July 1. The session and the July 3 closure were verified from observed bars — never assumed (the exchange-calendar dataset only carries upcoming closures).
  • 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 5, 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 1. The week: the four-session holiday week.

#recap#daily#spy#qqq#market structure