codependent.sty

%% ===================================================================
%% Section 1: Identification
%% ===================================================================
\NeedsTeXFormat{LaTeX2e}[2021/06/01]
\ProvidesPackage{codependent}[2026/04/10 v1.0 %
  Pavlov-style atom numbering and back-reference display]

%% ===================================================================
%% Section 2: Required packages
%% ===================================================================
\RequirePackage{etoolbox}
\RequirePackage{pgfkeys}

%% ===================================================================
%% Section 3: Options
%% ===================================================================

% Depth: how many sectioning levels in the atom display number.
%% @utility
\newcommand*{\codep@depth}{1}

% Back-references: inline (default), appendix, or none.
%% @utility
\newcommand*{\codep@backrefmode}{inline}
\newbool{codep@backrefs}
\booltrue{codep@backrefs}
\newbool{codep@appendix}
\boolfalse{codep@appendix}

% Proofs: on (default) or off.
\newbool{codep@proofsnumbered}
\booltrue{codep@proofsnumbered}

% Proof warnings: on (default) or off.
% Controls the "proof not adjacent to tracked environment" warning.
\newbool{codep@proofwarnings}
\booltrue{codep@proofwarnings}

% Auto-attribution conflict warnings: on (default) or off.
% Controls the D3 warning when a proof heading overrides adjacency.
\newbool{codep@warnattributionconflicts}
\booltrue{codep@warnattributionconflicts}

% Concept warnings: on (default) or off.
\newbool{codep@conceptwarnings}
\booltrue{codep@conceptwarnings}

% Paragraphs: on (default) or off.
% When off, bare paragraphs get no atom numbers, no SBL records, no backrefs.
\newbool{codep@paragraphs}
\booltrue{codep@paragraphs}

% Equation tracking mode: outer (default), all, off.
%% @utility
\newcommand*{\codep@equationmode}{outer}

% Rendering configuration (backref style, fonts).
%% @utility
\newcommand*{\codep@backrefstyle}{inline}
% String constants for \ifx comparisons in rendering macros.
%% @utility
\def\codep@const@inline{inline}
%% @utility
\def\codep@const@off{off}
%% @utility
\def\codep@const@outer{outer}
%% @utility
\def\codep@const@all{all}
%% @utility
\newcommand*{\codep@backreffont}{\scriptsize\sffamily}
%% @utility
\newcommand*{\codep@backrefcolor}{}
%% @utility
\newcommand*{\codep@backrefprefix}{}
%% @utility
\newcommand*{\codep@backreflabel}{Used in}
%% @utility
\newcommand*{\codep@marginfont}{\scriptsize}
%% @utility
\edef\codep@appendix@pagenum@template{%
  \detokenize{##1~(p.\@~##2)}}%
%% @utility
\def\codep@setappendixpagenumformat#1{%
  \toks@{#1}%
  \edef\codep@appendix@pagenum@template{%
    \detokenize\expandafter{\the\toks@}}%
}%
%% @utility
\def\codep@renderappendixpagenumtemplate#1#2{%
  \begingroup%
    \endlinechar=-1\relax%
    \edef\codep@tmp@appendixpagenum{%
      \endgroup%
      \noexpand\makeatletter%
      \noexpand\scantokens{%
        \def\noexpand\codep@tmp@appendixpagenum@stored{%
          \codep@appendix@pagenum@template}}%
      \noexpand\makeatother%
    }%
  \codep@tmp@appendixpagenum%
  \edef\codep@tmp@appendixpagenum{%
    \def\noexpand\codep@tmp@appendixpagenum@apply####1####2{%
      \codep@tmp@appendixpagenum@stored}}%
  \codep@tmp@appendixpagenum%
  \codep@tmp@appendixpagenum@apply{#1}{#2}%
}%

\pgfkeys{%
  /codep/.is family,%
  /codep/.cd,%
  depth/.store in = \codep@depth,%
  depth/.default = 1,%
  backrefs/.is choice,%
  backrefs/inline/.code = {%
    \booltrue{codep@backrefs}%
    \boolfalse{codep@appendix}%
    \renewcommand*{\codep@backrefmode}{inline}%
  },%
  backrefs/appendix/.code = {%
    \booltrue{codep@backrefs}%
    \booltrue{codep@appendix}%
    \renewcommand*{\codep@backrefmode}{appendix}%
  },%
  backrefs/none/.code = {%
    \boolfalse{codep@backrefs}%
    \boolfalse{codep@appendix}%
    \renewcommand*{\codep@backrefmode}{none}%
  },%
  backrefs/.default = inline,%
  proofs/.is choice,%
  proofs/on/.code = {\booltrue{codep@proofsnumbered}},%
  proofs/off/.code = {\boolfalse{codep@proofsnumbered}},%
  proofs/.default = on,%
  proof-warnings/.is choice,%
  proof-warnings/on/.code = {\booltrue{codep@proofwarnings}},%
  proof-warnings/off/.code = {\boolfalse{codep@proofwarnings}},%
  proof-warnings/.default = on,%
  % see @behavior B-WARN-ATTR-CONFLICTS at
  % \codep@proof@maybeheadingoverrideadjacent
  warn-attribution-conflicts/.is choice,%
  warn-attribution-conflicts/true/.code = {%
    \booltrue{codep@warnattributionconflicts}},%
  warn-attribution-conflicts/false/.code = {%
    \boolfalse{codep@warnattributionconflicts}},%
  warn-attribution-conflicts/on/.code = {%
    \booltrue{codep@warnattributionconflicts}},%
  warn-attribution-conflicts/off/.code = {%
    \boolfalse{codep@warnattributionconflicts}},%
  warn-attribution-conflicts/.default = true,%
  conceptwarnings/.is choice,%
  conceptwarnings/on/.code = {\booltrue{codep@conceptwarnings}},%
  conceptwarnings/off/.code = {\boolfalse{codep@conceptwarnings}},%
  conceptwarnings/.default = on,%
  paragraphs/.is choice,%
  paragraphs/on/.code = {\booltrue{codep@paragraphs}},%
  paragraphs/off/.code = {\boolfalse{codep@paragraphs}},%
  paragraphs/.default = on,%
  equations/.is choice,%
  equations/all/.code = {\def\codep@equationmode{all}},%
  equations/outer/.code = {\def\codep@equationmode{outer}},%
  equations/off/.code = {\def\codep@equationmode{off}},%
  equations/.default = outer,%
  backref-style/.is choice,%
  backref-style/below/.code = {%
    \PackageError{codependent}{%
      backref-style=below|margin removed in v2.0 --- use %
      \string\codepbackrefs\space in a custom %
      \string\newtheoremstyle\space endmark %
      (see docs/COOKBOOK.md)}{%
      The below and margin render styles were replaced by %
      \string\codepbackrefs, a user-driven hook that places the %
      backref wherever the theorem style prefers.}%
  },%
  backref-style/inline/.code = {\renewcommand*{\codep@backrefstyle}{inline}},%
  backref-style/margin/.code = {%
    \PackageError{codependent}{%
      backref-style=below|margin removed in v2.0 --- use %
      \string\codepbackrefs\space in a custom %
      \string\newtheoremstyle\space endmark %
      (see docs/COOKBOOK.md)}{%
      The below and margin render styles were replaced by %
      \string\codepbackrefs, a user-driven hook that places the %
      backref wherever the theorem style prefers.}%
  },%
  backref-style/.default = inline,%
  backref-font/.store in = \codep@backreffont,%
  backref-color/.store in = \codep@backrefcolor,%
  backref-prefix/.store in = \codep@backrefprefix,%
  backref-label/.store in = \codep@backreflabel,%
  appendix/pagenum-format/.code = {%
    \codep@setappendixpagenumformat{#1}%
  },%
  appendix-display/.code={\pgfkeys{/codep/appendix-display/.cd,#1}},%
  margin-font/.store in = \codep@marginfont,%
}
% Collect all options and forward to pgfkeys.
%% @utility
\def\codep@rawopts{}%
\DeclareOption*{%
  \ifx\codep@rawopts\@empty
    \edef\codep@rawopts{\CurrentOption}%
  \else
    \edef\codep@rawopts{\codep@rawopts,\CurrentOption}%
  \fi
}%
\ProcessOptions\relax
\ifx\codep@rawopts\@empty\else
%% @utility
  \edef\codep@tmp@opts{%
    \noexpand\pgfkeys{/codep/.cd,\codep@rawopts}%
  }%
  \codep@tmp@opts
\fi

% \codepsetup{key=value,...}  Configure codependent in preamble or body.
%% @utility
\newcommand*{\codepsetup}[1]{\pgfkeys{/codep/.cd,#1}}

%% ===================================================================
%% Section 4: Internal state
%% ===================================================================

% Base counter name: auto-detected from the first env in \codeptrack.
%% @utility
\newcommand*{\codep@basecounter}{}

% Monotone internal source-atom IDs (a1, a2, ...).
\newcount\codep@atomid
\codep@atomid=0\relax

% Monotone internal target IDs (q1, q2, ...).
\newcount\codep@targetid
\codep@targetid=0\relax

% Source-context stack depth.
\newcount\codep@ctxdepth
\codep@ctxdepth=0\relax

% Paragraph suppression depth.
\newcount\codep@suppressdepth
\codep@suppressdepth=0\relax
\newcount\codep@sourceblockdepth
\codep@sourceblockdepth=0\relax

% Tracked theorem-like nesting depth.
\newcount\codep@trackeddepth
\codep@trackeddepth=0\relax

% Restatable replay depth.
\newcount\codep@replaydepth
\codep@replaydepth=0\relax

% Flag: true when a paragraph atom is currently open.
\newif\ifcodep@paragraphopen
\codep@paragraphopenfalse

% Flag: true when the current proof still lacks display identity.
\newif\ifcodep@proofdisplaypending
\codep@proofdisplaypendingfalse

% Flag: true only while the current proof heading may auto-bind itself.
\newif\ifcodep@autoproofof@eligible
\codep@autoproofof@eligiblefalse

% Scratch count for proof-heading reference auto-detection.
\newcount\codep@autoproofof@refcount
\codep@autoproofof@refcount=0\relax

% Document-scoped counter for unresolved-reference identities.
\newcount\codep@autoproofof@unresrefcount
\codep@autoproofof@unresrefcount=0\relax

% Flag: true when the last proof-of resolver call bound a target.
\newif\ifcodep@proofof@resolved
\codep@proofof@resolvedfalse

% Flag: true when the current proof has a staged adjacent candidate
% waiting for post-heading-scan commitment.
%% @utility
\newif\ifcodep@proof@adjcommit@needed
\codep@proof@adjcommit@neededfalse

% Per-proof count of successful explicit/auto proof-attribution
% resolutions.  Stored in csname family
% \codep@proofof@attribcount@<proof-id> so repeated explicit
% attributions in one proof can be treated as intentional joint
% attribution rather than a key rename.

% Flag: abort finalization — set by \codep@enddoc@evaluator@pre when
% a fatal enddoc state is detected (e.g. unsettled proof-binding slot,
% or a subsystem counter reporting incomplete work we cannot recover
% from).  The orchestrator branches on this flag: when true, drains
% are skipped and \codep@enddoc@halt fires \PackageError.
% Runtime-only; NOT written to .aux, so a restart-retry begins clean.
%% @utility
\newif\ifcodep@abortfinalize
\codep@abortfinalizefalse

% Subsystem counter registry — walked by the two-tier evaluator.
% Each subsystem tracks a (total, failed) pair: `total` increments
% every time a tracked operation is attempted at non-replay time;
% `failed` increments when an operation cannot complete.  The
% orchestrator's pre-drain evaluator flips \codep@abortfinalizetrue
% when any registered subsystem has failed==total && total>0 (i.e.
% EVERY operation failed — drains would emit only stale records).
% The post-drain evaluator emits \PackageWarning per subsystem with
% 0<failed<total (partial success).
%% @utility
\newcommand*{\codep@subsystems@list}{}

% \codep@subsystem@init{name}
%   Declare a subsystem counter pair and register it on the
%   subsystems list.  Called four times at package load (see
%   Section 9b).
%% @utility
%@effect state-only
\def\codep@subsystem@init#1{%
  \expandafter\newcount\csname codep@subsys@#1@total\endcsname%
  \csname codep@subsys@#1@total\endcsname=0\relax%
  \expandafter\newcount\csname codep@subsys@#1@failed\endcsname%
  \csname codep@subsys@#1@failed\endcsname=0\relax%
  \g@addto@macro\codep@subsystems@list{\do{#1}}%
}%

% \codep@subsystem@recordtotal{name}
%   Increment the total-attempts counter for subsystem <name>.
%   Guarded on \codep@replaydepth so restatable theorems do not
%   double-count.  This guard is authoritative — callsites
%   should NOT double-wrap in a replay-depth check.
%% @utility
\def\codep@subsystem@recordtotal#1{%
  \ifnum\codep@replaydepth=0\relax%
    \global\advance\csname codep@subsys@#1@total\endcsname by 1\relax%
  \fi%
}%

% \codep@subsystem@recordfailed{name}
%   Increment the failed-operations counter for subsystem <name>.
%   Same replay guard as recordtotal.
%% @utility
\def\codep@subsystem@recordfailed#1{%
  \ifnum\codep@replaydepth=0\relax%
    \global\advance\csname codep@subsys@#1@failed\endcsname by 1\relax%
  \fi%
}%

% Four subsystem registrations.  `proofof` tracks \codepproofof
% resolution attempts (recordfailed on slot-overwrite + unsettled
% slot at enddoc).  `atomref` tracks \codep@writerefevent calls.
% `label-bind` tracks \codep@recordlabelowner calls.  `backref-render`
% tracks render-layer preparebackref calls (no-op count when render
% layer is absent, since the no-op stub in codependent.sty:342
% does not increment).
\codep@subsystem@init{proofof}%
\codep@subsystem@init{atomref}%
\codep@subsystem@init{label-bind}%
\codep@subsystem@init{backref-render}%

% Pending proof-adjacent result atom ID.
%% @utility
\newcommand*{\codep@pendingresultid}{}

% Current proof atom ID (empty outside proofs).
%% @utility
\newcommand*{\codep@currentproofid}{}

% Labels captured by the proof-heading auto-detect scanner.
%% @utility
\newcommand*{\codep@autoproofof@pendinglist}{}

% Same-scan provisional source key for unresolved proof-heading refs.
%% @utility
\newcommand*{\codep@autoproofof@provkey}{}

% Proof target metadata accumulator keys.  The authoritative per-proof
% payload is stored in csnames keyed by the stable proof:a<N> identity;
% this do-list only remembers which proof keys need aux / cdp emission.
%% @utility
\gdef\codep@prooftargetmetalist{}

% Saved nested-proof state.
\newtoks\codep@proofneststack
\codep@proofneststack={}

% Deferred proof-binding marker.  Non-empty when a proof-binding
% declaration (e.g., \codepproofin — planned future API) was made
% but the proof environment has not yet begun to consume it.
% Cleared at every \let\@empty site; the sibling slots below
% carry the contextual details needed by the overwrite and
% unsettled-slot warnings.
%% @utility
\newcommand*{\codep@pendingproofbind}{}

% Sibling capture slots for the pending proof-binding.  Populated
% alongside \codep@pendingproofbind whenever a binding is
% declared; used by \codep@pendingproofbind@checkoverwrite and by
% \codep@enddoc@drain@proofs when warning about an unsettled
% slot.  Kept empty when \codep@pendingproofbind is empty.
%% @utility
\newcommand*{\codep@pendingproofbind@line}{}
%% @utility
\newcommand*{\codep@pendingproofbind@label}{}

% \codep@pendingproofbind@checkoverwrite
%   Called immediately before any site that \let\@empty-clears
%   \codep@pendingproofbind outside the save/restore pair.  If
%   the slot is non-empty at check time, emits one
%   \PackageWarning + \codep@subsystem@recordfailed{proofof} and
%   clears the sibling slots; the caller then performs its own
%   \let\@empty on the main slot.  Safe to call when the slot is
%   already empty (no-op).
%% @utility
\def\codep@pendingproofbind@checkoverwrite{%
  \ifx\codep@pendingproofbind\@empty\else%
    \codep@subsystem@recordfailed{proofof}%
    \PackageWarning{codependent}{proof-bind slot overwritten -- previous binding to '\codep@pendingproofbind@label' at input line \codep@pendingproofbind@line\space was lost}%
    \global\let\codep@pendingproofbind@line\@empty%
    \global\let\codep@pendingproofbind@label\@empty%
  \fi%
}%

% Saved atom number for the outermost tracked env.  When nesting
% occurs, \theatom at end-time reflects the LAST \refstepcounter
% (the inner env), not the outermost.  This macro captures the
% correct value after the outermost env's \refstepcounter fires.
%% @utility
\newcommand*{\codep@outeratom}{}

% Pending-clear stashes for the per-atom \codep@manuallyemitted@<key>
% flag.  Populated at the source hook site (where the atom key is
% still resolvable), consumed at the *post-env* hook site (after the
% ctx stack pop).  See Section 6 (\codep@hooktheorem orchestrator)
% and Section 6 (\codep@hookproof@afterend).
%% @utility
\newcommand*{\codep@endenv@pendingclear}{}
%% @utility
\newcommand*{\codep@proofend@pendingclear}{}

% Nested-proof save/restore stashes for adjacent-proof state.
%% @utility
\newcommand*{\codep@proofadj@pendinganchormapkey}{}
%% @utility
\newcommand*{\codep@proofadj@pendinganchormapanchor}{}

% Flag: true when \codeptrack has been called.
\newbool{codep@tracked}
\boolfalse{codep@tracked}

% Flag: true when a sectioning heading paragraph is pending.
% Set by the \@startsection wrapper, cleared after one para/begin.
\newbool{codep@sectioning}
\boolfalse{codep@sectioning}

% Flag: true inside a tracked equation environment.
\newbool{codep@inequation}
\boolfalse{codep@inequation}

% Track 1 / Track 2 source-ownership state for equations.
%% @utility
\newcommand*{\codep@currenteqsourceid}{}
%% @utility
\newcommand*{\codep@eqfallbacksourceid}{}

% Track 1: current equation atom (set at \ref time for single-number envs).
%% @utility
\newcommand*{\codep@eqatom}{}

% Track 2: pending ref targets for multi-number envs.
\newtoks\codep@eqpending
\codep@eqpending={}
\newcount\codep@eqpendingcount
\codep@eqpendingcount=0\relax
% Track 2: pending-append guard cleanup tokens (SW5c commit 2).
% Cleared at each equation-block begin to reset \codep@arw@pending@<tgt>.
\newtoks\codep@eqpendguards
\codep@eqpendguards={}

% Track 2: saved equation counter at \begin{align}.
\newcount\codep@eq@startcount
\codep@eq@startcount=0\relax

% Track 2: dedicated anchor name for the block.
%% @utility
\newcommand*{\codep@eq@anchor}{}

% Track 2 flag: distinguishes Track 1 vs Track 2 envs.
\newbool{codep@eqmultiline}
\boolfalse{codep@eqmultiline}

% Flag: true when the current equation block produced a number.
\newbool{codep@eqnumbered}
\boolfalse{codep@eqnumbered}

% Standalone-equation label type pending.
% Set globally at \AtBeginEnvironment for standalone equations so
% that deferred \label calls (amsmath fires them after environment end)
% can still record the correct type.  Cleared in \codep@writelbltype
% after use, and globally cleared at environment end as a safety net.
%% @utility
\newcommand*{\codep@eq@lbltype@pending}{}

% Accumulated appendix data (token register).
% Still referenced by \codepappendix (Section 10); Wave 3 rewires
% its population path per §8a.6.g.
\newtoks\codep@appendixdata

% Count-indexed atom array for appendix mode (§8a.6.g).
% Each \codep@atom@<n> expands to {<num>}{<type>}.
% O(1) append via csname array; O(N) walk in \codepappendix.
\newcount\codep@atomcount

% Current section number and title for appendix section grouping.
% Updated by the \addcontentsline hook when a toc/section entry
% is written.  Stored per-atom at registration time so that
% \codepappendix can emit section headers.
%% @utility
\newcommand*{\codep@cursecnum}{}%
%% @utility
\newcommand*{\codep@cursectitle}{}%

% Sidecar (.cdp) stream state (§9a).
\newbool{codep@cdpopen}
\boolfalse{codep@cdpopen}

% Deferred sbl writes: preamble cmddef records accumulate here
% and flush once the .cdp stream opens at begindocument/before.
%% @utility
\def\codep@cdp@deferred{}

%% --- Rendering hook points (no-op defaults) ---
%% These are redefined to their live implementations after all
%% rendering code is loaded (see "Rendering hook activation" below).
%% When tracking runs without a rendering layer, these are inert.
%% @utility
\def\codep@render@refresh#1{}%
%% @utility
\def\codep@render@flushbackref#1{}%
%% @utility
\def\codep@render@thm@preparebackref#1{}%
%% @utility
\def\codep@render@thm@afterend#1{}%
%% @utility
\def\codep@render@proof@end{}%
%% @utility
\def\codep@render@proof@afterend{}%
%% @utility
\def\codep@render@para@emit#1#2{}%
%% @utility
\def\codep@render@manual@emit#1{}%

% \codep@manuallyemitted@clear@key{atomkey}
%   Globally undefine \codep@manuallyemitted@<atomkey>.  The csname
%   form must use \@undefined (not \relax) so that subsequent
%   \ifcsdef tests at auto-flush sites correctly return false.
%   Mirrors the undef idioms in \codep@ctxpop and
%   \codep@proofstaterestore.
%% @utility
\def\codep@manuallyemitted@clear@key#1{%
  \csgundef{codep@manuallyemitted@#1}%
}%

%% ===================================================================
%% Section 4a: Runtime helpers
%% ===================================================================

% Proof atoms are identified by their opaque key (proof:a<N>) only;
% see @behavior B-PROOF-OPAQUE-ID at \codep@proof@identitykey.
% there is no display-keyed alias. \hyperref[proof:1.2]{...} is NOT
% supported -- users must reference proof atoms by their proof:a<N>
% key (extractable from the .cdp file).
%
% A generic display->atom sidecar rail will be added in Wave E
% (sub-item E1) to support display-keyed reverse lookup for joint
% proofs, per-result ordinals, continued theorems, and cross-doc.
%% @utility
% \codep@allocatomid{macro}{kind}
%   Allocate a fresh opaque source-atom ID (aN) into macro.
\def\codep@allocatomid#1#2{%
  \global\advance\codep@atomid by 1\relax
  \xdef#1{a\the\codep@atomid}%
  \csxdef{codep@atomkind@#1}{#2}%
}%

%% @utility
% \codep@alloctargetid{macro}{kind}
%   Allocate a fresh opaque target ID (qN) into macro.
\def\codep@alloctargetid#1#2{%
  \global\advance\codep@targetid by 1\relax
  \xdef#1{q\the\codep@targetid}%
  \csxdef{codep@targetkind@#1}{#2}%
}%

%% @utility
% \codep@ctxpush{atom-id}{kind}
%   Push one source context entry onto the global stack.
\def\codep@ctxpush#1#2{%
  \global\advance\codep@ctxdepth by 1\relax%
  \csxdef{codep@ctxid@\the\codep@ctxdepth}{#1}%
  \csxdef{codep@ctxkind@\the\codep@ctxdepth}{#2}%
}%

%% @utility
% \codep@ctxpop{kind}
%   Pop one source context entry, hard-erroring on mismatch.
\def\codep@ctxpop#1{%
  \ifnum\codep@ctxdepth<1\relax%
    \PackageError{codependent}{Context stack underflow on '#1'}{%
      codependent detected an internal stack underflow while%
      closing '#1'.}%
  \else%
    \edef\codep@tmp@ctxkind{%
      \csuse{codep@ctxkind@\the\codep@ctxdepth}}%
    \def\codep@tmp@expected{#1}%
    \ifx\codep@tmp@ctxkind\codep@tmp@expected\else%
      \PackageError{codependent}{Context stack mismatch on '#1'}{%
        Expected to pop '#1' but found '\codep@tmp@ctxkind'.}%
    \fi%
    \csgundef{codep@ctxid@\the\codep@ctxdepth}%
    \csgundef{codep@ctxkind@\the\codep@ctxdepth}%
    \global\advance\codep@ctxdepth by -1\relax%
  \fi%
}%

%% @utility
% \codep@ctxpeekid{macro}
%   Store the top source-context ID into macro, else \@empty.
\def\codep@ctxpeekid#1{%
  \ifnum\codep@ctxdepth<1\relax%
    \let#1\@empty%
  \else%
    \letcs#1{codep@ctxid@\the\codep@ctxdepth}%
  \fi%
}%

%% @utility
% \codep@ctxpeekkind{macro}
%   Store the top source-context kind into macro, else \@empty.
\def\codep@ctxpeekkind#1{%
  \ifnum\codep@ctxdepth<1\relax%
    \let#1\@empty%
  \else%
    \letcs#1{codep@ctxkind@\the\codep@ctxdepth}%
  \fi%
}%

%% @utility
% \codep@atomsetkey{atom-id}{prefixed-key}
%   Persist the legacy prefixed key derived for this atom.
\def\codep@atomsetkey#1#2{%
  \csxdef{codep@atomkey@#1}{#2}%
  \csxdef{codep@idbykey@#2}{#1}%
  \expandafter\codep@splitprefix#2\@nil%
  \csxdef{codep@atomdisplay@#1}{%
    \codep@tmp@num}%
}%

%% @utility
% \codep@atomgetkey{atom-id}{macro}
%   Store the legacy prefixed key for atom-id into macro.
\def\codep@atomgetkey#1#2{%
  \ifx#1\@empty%
    \let#2\@empty%
  \else%
    \ifcsundef{codep@atomkey@#1}{%
      \let#2\@empty%
    }{%
      \letcs#2{codep@atomkey@#1}%
    }%
  \fi%
}%

%% @utility
% \codep@atomgetdisplay{atom-id}{macro}
%   Store the bare legacy display number for atom-id into macro.
\def\codep@atomgetdisplay#1#2{%
  \ifx#1\@empty%
    \let#2\@empty%
  \else%
    \ifcsundef{codep@atomdisplay@#1}{%
      \let#2\@empty%
    }{%
      \letcs#2{codep@atomdisplay@#1}%
    }%
  \fi%
}%

%% @utility
% \codep@atomgetkind{atom-id}{macro}
%   Store the registered kind for atom-id into macro.
\def\codep@atomgetkind#1#2{%
  \ifx#1\@empty%
    \let#2\@empty%
  \else%
    \ifcsundef{codep@atomkind@#1}{%
      \let#2\@empty%
    }{%
      \letcs#2{codep@atomkind@#1}%
    }%
  \fi%
}%

%% @utility
% \codep@keytoid{prefixed-key}{macro}
%   Resolve a legacy prefixed key back to an internal atom ID.
\def\codep@keytoid#1#2{%
  \ifcsundef{codep@idbykey@#1}{%
    \let#2\@empty%
  }{%
    \letcs#2{codep@idbykey@#1}%
  }%
}%

%% @implements \codep@writerefevent
% \codep@getcurrentownerid{macro}
%   Resolve the active owning atom ID, honouring proof pending state.
\def\codep@getcurrentownerid#1{%
  \ifnum\codep@replaydepth>0\relax%
    \let#1\@empty%
  \else%
    \codep@ctxpeekkind\codep@tmp@ctxkind%
    \codep@ctxpeekid\codep@tmp@ctxid%
    \def\codep@tmp@proofkind{proof}%
    \ifx\codep@tmp@ctxkind\@empty%
      \let#1\@empty%
    \else\ifx\codep@tmp@ctxkind\codep@tmp@proofkind%
      \ifcodep@proofdisplaypending%
        \let#1\@empty%
      \else%
        \let#1\codep@tmp@ctxid%
      \fi%
    \else%
      \let#1\codep@tmp@ctxid%
    \fi\fi%
  \fi%
}%

%% @implements \codep@writerefevent
% \codep@getcurrentatomkey{macro}
%   Resolve the active source atom's legacy prefixed key.
\def\codep@getcurrentatomkey#1{%
  \ifnum\codep@sourceblockdepth>0\relax%
    \let#1\@empty%
  \else%
    \codep@getcurrentownerid\codep@tmp@ownerid%
    \codep@atomgetkey{\codep@tmp@ownerid}{#1}%
  \fi%
}%

%% @implements \codep@recordlabelowner
% \codep@getcurrentatomdisplay{macro}
%   Resolve the active source atom's bare legacy display number.
\def\codep@getcurrentatomdisplay#1{%
  \codep@getcurrentatomkey\codep@tmp@atomkey%
  \ifx\codep@tmp@atomkey\@empty%
    \let#1\@empty%
  \else%
    \expandafter\codep@splitprefix\codep@tmp@atomkey\@nil%
    \let#1\codep@tmp@num%
  \fi%
}%

%% @implements \codep@recordlabelowner
% \codep@getcurrentatomkind{macro}
%   Resolve the active source atom's legacy type prefix.
\def\codep@getcurrentatomkind#1{%
  \codep@getcurrentatomkey\codep@tmp@atomkey%
  \ifx\codep@tmp@atomkey\@empty%
    \let#1\@empty%
  \else%
    \expandafter\codep@splitprefix\codep@tmp@atomkey\@nil%
    \let#1\codep@tmp@type%
  \fi%
}%

%% @behavior B-NUM-PARA
% \codep@closeparagraphifopen
%   Finalise the current paragraph atom, if any.
\def\codep@closeparagraphifopen{%
  \ifcodep@paragraphopen%
    \codep@ctxpop{paragraph}%
    \global\codep@paragraphopenfalse%
  \fi%
}%

%% @behavior B-NUM-EQINDEP
% \codep@recordlabelowner{label}
%   Write the legacy label-type ownership record for label, and
%   (W03-P03) populate the in-memory label->entity binding table +
%   emit the \codep@lblentity aux record.  Same replay guard covers
%   both.
%@effect immediate-write
\def\codep@recordlabelowner#1{%
  \if@filesw%
    \ifnum\codep@replaydepth>0\relax%
    \else%
      \codep@subsystem@recordtotal{label-bind}%
      \ifx\codep@eq@lbltype@pending\@empty%
        \codep@getcurrentatomkind\codep@tmp@labelkind%
        \ifx\codep@tmp@labelkind\@empty\else%
          \csgdef{codep@ltype@#1}{%
            \codep@tmp@labelkind}%
          \protected@write\@auxout{}{%
            \string\codep@lbltype{#1}{\codep@tmp@labelkind}}%
        \fi%
      \else%
        \csgdef{codep@ltype@#1}{%
          \codep@eq@lbltype@pending}%
        \protected@write\@auxout{}{%
          \string\codep@lbltype{#1}{\codep@eq@lbltype@pending}}%
      \fi%
      % W03-P03: in-memory label->entity binding + cross-run aux record.
      % Skip if no owning atom-key is resolvable at this point (e.g.,
      % \label outside any tracked env, or equation label before the
      % equation's atom-key is materialised).
      \codep@getcurrentatomkey\codep@tmp@lblentity%
      \ifx\codep@tmp@lblentity\@empty\else%
        % \xdef (not \gdef) so the csname stores the expanded
        % atom-key string, not a reference to \codep@tmp@lblentity
        % whose binding is local to this \codep@recordlabelowner
        % call and is undefined outside.
        \csxdef{codep@lblentity@#1}{%
          \codep@tmp@lblentity}%
        \csgdef{codep@lblentity@samerun@#1}{1}%
        \protected@write\@auxout{}{%
          \string\codep@lblentity{#1}{\codep@tmp@lblentity}}%
      \fi%
    \fi%
  \fi%
}%

%% @behavior B-DEDUP
%% @behavior B-EDGE-HEADING
% \codep@writerefevent{label}
%   Emit one legacy atomref write from the active source atom.
%@effect immediate-write
\def\codep@writerefevent#1{%
  \if@filesw%
    \codep@autoproofof@ifheadsuppressed{#1}{}{%
      \codep@proof@ifadjacenttargetsuppressed{#1}{}{%
        \codep@getcurrentatomkey\codep@tmp@srcatom%
        \ifx\codep@tmp@srcatom\@empty\else%
          \codep@subsystem@recordtotal{atomref}%
          \codep@dedupwrite{\codep@tmp@srcatom}{#1}%
        \fi%
      }%
    }%
  \fi%
}%

% \codep@proof@identitykey{proof-id}{macro}
%   Return the stable proof:a<N> source key for proof-id.
%% @behavior B-PROOF-OPAQUE-ID
\def\codep@proof@identitykey#1#2{%
  \edef#2{proof:#1}%
}%

% \codep@proof@setidentity{proof-id}
%   Make proof:a<N> the current atom key for proof-id.
%% @implements \codep@bindproofparent
\def\codep@proof@setidentity#1{%
  \codep@proof@identitykey{#1}{\codep@tmp@proofidentitykey}%
  \codep@atomsetkey{#1}{\codep@tmp@proofidentitykey}%
}%

% \codep@proof@markparent{proof-id}{target-key}
%   Remember that proof-id has at least one target parent.
%% @implements \codep@bindproofparent
\def\codep@proof@markparent#1#2{%
  \ifcsundef{codep@proofparent@#1}{%
    \csxdef{codep@proofparent@#1}{#2}%
  }{%
    \ifcsempty{codep@proofparent@#1}{%
      \csxdef{codep@proofparent@#1}{#2}%
    }{}%
  }%
}%

% \codep@proof@maybeheadingoverrideadjacent{proof-id}{target-key}{display}
%   D3 policy: first tracked heading target supersedes adjacent binding.
%% @behavior B-PROOF-HEADING-OVERRIDE
%% @behavior B-WARN-ATTR-CONFLICTS
\def\codep@proof@maybeheadingoverrideadjacent#1#2#3{%
  \ifcsundef{codep@proofadjtarget@#1}{}{%
    \ifcsundef{codep@proofheadingoverride@#1}{%
      \edef\codep@tmp@adjtarget{\csuse{codep@proofadjtarget@#1}}%
      \edef\codep@tmp@headingtarget{#2}%
      \ifx\codep@tmp@adjtarget\codep@tmp@headingtarget\else%
        \ifbool{codep@warnattributionconflicts}{%
          \PackageWarning{codependent}{auto-attribution to #3\space%
            supersedes adjacent \csuse{codep@proofadjdisplay@#1}}%
        }{}%
        \codep@proof@suppressadjacenttarget{#1}{\codep@tmp@adjtarget}%
      \fi%
      \codep@proof@identitykey{#1}{\codep@tmp@overrideproofkey}%
      \codep@prooftargetmeta@clear{\codep@tmp@overrideproofkey}%
      \csxdef{codep@proofparent@#1}{}%
      \global\cslet{codep@proofheadingoverride@#1}\@empty%
    }{}%
  }%
}%

% \codep@proof@suppressadjacenttarget{proof-id}{target-key}
%   Record the adjacent target displaced by proof-heading attribution.
%% @implements \codep@bindproofparent
\def\codep@proof@suppressadjacenttarget#1#2{%
  \csxdef{codep@proofsuppressadjacent@#1}{#2}%
}%

% \codep@proof@ifadjacenttargetsuppressed{label}{then}{else}
%   Suppress later proof-body references to the displaced adjacent target.
%% @implements \codep@writerefevent
\def\codep@proof@ifadjacenttargetsuppressed#1#2#3{%
  \ifx\codep@currentproofid\@empty%
    #3%
  \else%
    \ifcsundef{%
        codep@proofsuppressadjacent@%
          \codep@currentproofid}{%
      #3%
    }{%
      \ifcsundef{codep@lblentity@#1}{%
        #3%
      }{%
        \edef\codep@tmp@suppressadjacent{%
          \csuse{codep@proofsuppressadjacent@%
            \codep@currentproofid}}%
        \edef\codep@tmp@suppresstarget{\csuse{codep@lblentity@#1}}%
        \ifx\codep@tmp@suppressadjacent\codep@tmp@suppresstarget%
          #2%
        \else%
          #3%
        \fi%
      }%
    }%
  \fi%
}%

%% @behavior B-PROOF-ADJ
%% @behavior B-PROOF-SEP
%% @behavior B-PROOF-JOINT
% \codep@bindproofparent{proof-id}{parent-id}{mode}
%   Bind proof-id to parent-id using the stable proof:a<N> key and
%   append parent-id to the proof target metadata list.
%   The third argument (mode) is currently unused at the call site;
%   the parent slot's emptiness alone drives the renderer's
%   ADJACENT-or-REBOUND vs. STANDALONE classifier (see
%   \codep@graph@getentityparent).  Retained in the signature for
%   call-site clarity.
%   The parent slot stores the parent atom's prefixed key (e.g.
%   "theorem:1.1") rather than the raw atom-id so the entitymeta
%   parent value is consistent across adjacent and rebound paths
%   (\codep@proofof@resolve also writes a prefixed key).  The
%   classifier still only checks emptiness.
\def\codep@bindproofparent#1#2#3{%
  \codep@proof@setidentity{#1}%
  \codep@proof@identitykey{#1}{\codep@tmp@proofkey}%
  \codep@atomgetkey{#2}{\codep@tmp@parentprefixedkey}%
  \codep@atomgetdisplay{#2}\codep@tmp@parentdisplay%
  \ifx\codep@tmp@parentprefixedkey\@empty\else%
    \codep@proof@markparent{#1}{\codep@tmp@parentprefixedkey}%
    % see @behavior B-PROOF-JOINT at \codep@proofof@capturejointmeta.
    \codep@prooftargetmeta@append{\codep@tmp@proofkey}{%
      \codep@tmp@parentprefixedkey}{\codep@tmp@parentdisplay}{*}%
  \fi%
}%

%% ===================================================================
%% Section 5: Core numbering machinery
%% ===================================================================

% \codep@removefromreset{counter}{parent}
%   Remove counter from parent's reset list.
%% @utility
%@effect state-only
\newcommand*{\codep@removefromreset}[2]{%
  \ifcsundef{@removefromreset}{%
    % Manual: rewrite \cl@parent without #1.
    \begingroup
      \letcs\codep@resetlist{cl@#2}%
      \global\cslet{cl@#2}\@empty%
      \def\@elt##1{%
        \def\codep@cur{##1}%
        \def\codep@tgt{#1}%
        \ifx\codep@cur\codep@tgt\else
          \expandafter\g@addto@macro%
            \csname cl@#2\endcsname{\@elt{##1}}%
        \fi
      }%
      \codep@resetlist%
    \endgroup
  }{%
    \@removefromreset{#1}{#2}%
  }%
}

% \codep@setupcounter
%   Create the atom counter and wire it to the base counter
%   (auto-detected from the first env in \codeptrack).
%   Called by \codeptrack.
%% @behavior B-NUM-SHARED
%@effect state-only
\newcommand*{\codep@setupcounter}{%
  \newcounter{atom}%
  % Copy current base counter value (if it exists).
  % Note: \ifcsundef uses \csname internally, which expands
  % \codep@basecounter automatically.
  \ifcsundef{c@\codep@basecounter}{}{%
    \setcounter{atom}{\value{\codep@basecounter}}%
  }%
  \codep@configuredepth%
  % Alias base counter register and display format to atom.
  \ifcsundef{c@\codep@basecounter}{}{%
    \codep@counter@alias@install{\codep@basecounter}{atom}%
  }%
}

% \codep@configuredepth
%   Set up counter resets and display format based on depth option
%   and document class.
%% @behavior B-NUM-DEPTH1
%% @behavior B-NUM-DEPTH2
%% @behavior B-NUM-RESET
%@effect state-only
\newcommand*{\codep@configuredepth}{%
  % Remove base counter from any existing reset parent.
  \ifcsundef{c@\codep@basecounter}{}{%
    \ifcsundef{cl@section}{}{%
      \expandafter\codep@removefromreset\expandafter{\codep@basecounter}{section}%
    }%
    \ifcsundef{cl@chapter}{}{%
      \expandafter\codep@removefromreset\expandafter{\codep@basecounter}{chapter}%
    }%
  }%
  \ifcsundef{chapter}{%
    \codep@configuredepth@article%
  }{%
    \codep@configuredepth@book%
  }%
}

% Article-class depth configuration.
%% @implements \codep@configuredepth
%@effect state-only
\newcommand*{\codep@configuredepth@article}{%
  \ifcase\codep@depth\relax
    % 0: invalid
    \PackageError{codependent}{Invalid depth '\codep@depth'}{%
      The depth option must be 1, 2, or 3.}%
  \or % 1
    \@addtoreset{atom}{section}%
    \renewcommand*{\theatom}{\thesection.\arabic{atom}}%
  \or % 2
    \@addtoreset{atom}{subsection}%
    \renewcommand*{\theatom}{%
      \thesection.\arabic{subsection}.\arabic{atom}}%
  \or % 3
    \@addtoreset{atom}{subsubsection}%
    \renewcommand*{\theatom}{%
      \thesection.\arabic{subsection}.%
      \arabic{subsubsection}.\arabic{atom}}%
  \else
    \PackageError{codependent}{Invalid depth '\codep@depth'}{%
      The depth option must be 1, 2, or 3.}%
  \fi
}

% Book/report-class depth configuration.
%% @implements \codep@configuredepth
%@effect state-only
\newcommand*{\codep@configuredepth@book}{%
  \ifcase\codep@depth\relax
    % 0: invalid
    \PackageError{codependent}{Invalid depth '\codep@depth'}{%
      The depth option must be 1, 2, or 3.}%
  \or % 1
    \@addtoreset{atom}{chapter}%
    \renewcommand*{\theatom}{\thechapter.\arabic{atom}}%
  \or % 2
    \@addtoreset{atom}{section}%
    \renewcommand*{\theatom}{%
      \thechapter.\arabic{section}.\arabic{atom}}%
  \or % 3
    \@addtoreset{atom}{subsection}%
    \renewcommand*{\theatom}{%
      \thechapter.\arabic{section}.%
      \arabic{subsection}.\arabic{atom}}%
  \else
    \PackageError{codependent}{Invalid depth '\codep@depth'}{%
      The depth option must be 1, 2, or 3.}%
  \fi
}

% \codep@registeratom{num}{kind}
%   Append one entry to the count-indexed atom array.
%   num  -- the atom number token (e.g. \codep@outeratom or \theatom)
%   kind -- the atom type string (e.g. {#1}, proof, paragraph)
%% @behavior B-REND-APPENDIX
\def\codep@registeratom#1#2{%
  \global\advance\codep@atomcount by 1\relax
  \csxdef{codep@atom@\the\codep@atomcount}{%
    {#1}{#2}}%
  % Store current section number for appendix grouping.
  \csxdef{codep@atom@sec@\the\codep@atomcount}{%
    \codep@cursecnum}%
}%

%% ===================================================================
%% Section 6: Theorem environment hooks
%% ===================================================================

% \codep@hooktheorem{envname}
%   Install begin/end hooks for a tracked theorem environment.
%   Uses LaTeX 2021+ cmd hooks (cmd/<env>/before) instead of
%   etoolbox's \AtBeginEnvironment so that hooks also fire when
%   thmtools' thm-restate.sty calls \theorem / \endtheorem
%   directly (bypassing \begin{theorem}).
%
%   Timing note (docs/DESIGN.md §8a.5.0): the cmd/before hook fires
%   BEFORE amsthm's \refstepcounter{theorem}, so \theatom at
%   begin-time is the PREVIOUS atom's number.  The render refresh
%   call is therefore in the end hook, where the env body has
%   run and \theatom reflects the current atom.
%   \codep@currentatom is demoted to a sentinel — its value
%   is not used, only its emptiness; we set it to a literal
%   "1" on begin and clear to \@empty on end.
%
%   Restatable guard (§8a.5.a): \codep@setupcounter aliases
%   \c@<basecounter> to \c@atom.  When thmtools' thm-restate.sty
%   re-fires the env for \restate, it breaks this alias
%   (\c@<basecounter> -> \c@thmt@dummyctr).  The \ifx guard
%   detects whether the alias is intact (original occurrence) or
%   broken (restate occurrence) and skips the hook body on
%   restate, preventing spurious atom attribution and duplicate
%   .cdp records.  All envs declared with
%   \newtheorem{...}[<basecounter>] share
%   \c@<basecounter>, so the guard covers all shared-counter
%   envs.  Envs with independent counters are not supported by
%   this guard and should not be passed to \codeptrack.
%
%   Note: the env name is captured via the hook argument (#1)
%   rather than \@currenvir, because under restatable the
%   current environment is "restatable", not the theorem type.
%
%   The hook bodies are factored into named helpers below;
%   \codep@hooktheorem is a thin orchestrator that wires them
%   into the five hook points.

%% @utility
\let\codep@thmwrap@activeenv\@empty

%% @implements \codep@hooktheorem
% \codep@hooktheorem@derivekey{envname}
%   Derive and persist the theorem's legacy prefixed key once the
%   theorem counter has stepped.
%@effect state-only
\def\codep@hooktheorem@derivekey#1{%
  \ifnum\codep@replaydepth=0\relax%
    \ifnum\codep@trackeddepth=1\relax%
      \codep@ctxpeekid\codep@thisatomid%
      \ifx\codep@thisatomid\@empty\else%
        \codep@atomgetkey{\codep@thisatomid}{\codep@tmp@existingkey}%
        \ifx\codep@tmp@existingkey\@empty%
          \xdef\codep@outeratom{#1:\theatom}%
          \codep@atomsetkey{\codep@thisatomid}{\codep@outeratom}%
        \else%
          \xdef\codep@outeratom{\codep@tmp@existingkey}%
        \fi%
      \fi%
    \fi%
  \fi%
}%

%% @implements \codep@hooktheorem
% \codep@hooktheorem@writeanchorandpage
%   Idempotently write the theorem body anchor/page records after begin.
%@effect immediate-write
\def\codep@hooktheorem@writeanchorandpage{%
  \ifnum\codep@trackeddepth=1\relax%
    \codep@ctxpeekid\codep@thisatomid%
    \ifx\codep@thisatomid\@empty\else%
      \ifcsundef{%
          codep@theoremanchorwritten@\codep@thisatomid%
      }{%
        \codep@getcurrentatomkey\codep@tmp@anchorkey%
        \ifx\codep@tmp@anchorkey\@empty\else%
          \codep@writeanchormap{\codep@tmp@anchorkey}%
          \codep@writeanchorpagecurrent{\codep@tmp@anchorkey}%
          \csxdef{codep@theoremanchorwritten@\codep@thisatomid}{1}%
        \fi%
      }{}%
    \fi%
  \fi%
}%

%% @behavior B-NUM-NESTED
%% @behavior B-EDGE-NESTED
%% @behavior B-EDGE-RESTATE
% \codep@hooktheorem@begin{envname}
%   Begin-hook body for tracked theorem-like environments.
%@effect state-only
\def\codep@hooktheorem@begin#1{%
  \codep@closeparagraphifopen%
  \global\let\codep@pendingresultid\@empty%
  \gdef\codep@thmwrap@activeenv{#1}%
  \ifcsequal{c@\codep@basecounter}{c@atom}{%
    \global\advance\codep@trackeddepth by 1\relax%
    \global\advance\codep@suppressdepth by 1\relax%
    \ifnum\codep@trackeddepth>1\relax%
      \PackageWarning{codependent}{Nested tracked environment '#1'\space%
        inside another tracked environment. The inner\space%
        environment will not be assigned its own atom number}%
    \else%
      \codep@allocatomid{\codep@thisatomid}{#1}%
      \codep@ctxpush{\codep@thisatomid}{#1}%
    \fi%
  }{%
    \global\advance\codep@replaydepth by 1\relax%
    \global\advance\codep@suppressdepth by 1\relax%
  }%
}%

%% @behavior B-NUM-STARRED
% \codep@hooktheorem@after{envname}
%   Finalize theorem key derivation and write the post-begin anchor/page.
%   Anchor capture uses the theorem's own \@currentHref; the extractanchor
%   mechanism (§8a.5) may overwrite codep@anchor@<key> on pass 2+ when
%   an in-theorem equation with the same display number is the effective
%   anchor.
%@effect immediate-write
\def\codep@hooktheorem@after#1{%
  \ifnum\codep@trackeddepth=1\relax%
    \codep@hooktheorem@derivekey{#1}%
    \codep@hooktheorem@writeanchorandpage%
  \fi%
  \global\let\codep@thmwrap@activeenv\@empty%
}%

%% @behavior B-NUM-SEQ
% \codep@hooktheorem@record{envname}
%   Emit the theorem's legacy .cdp records and appendix entry.
%@effect immediate-write
\def\codep@hooktheorem@record#1{%
  \expandafter\codep@splitprefix\codep@outeratom\@nil%
  \codep@cdpwrite@atom{%
    \string\codep@cdp@atom{\codep@tmp@num}{#1}}%
  \codep@cdpwrite@atom{%
    \string\codep@cdp@meta{\codep@tmp@num}{env}{#1}}%
  \codep@cdpwrite@atom{%
    \string\codep@cdp@meta{\codep@tmp@num}{src}%
      {\jobname.tex:\the\inputlineno:1}}%
  \codep@registeratom{\codep@outeratom}{#1}%
}%

% \codep@hooktheorem@preparebackref{envname}
%   Refresh backrefs, apply orphan prevention, flush inline style.
%   Block/margin styles flush later in \AfterEndEnvironment.
%   Delegates to the rendering hook point.
%% @implements \codep@hooktheorem
%@effect inline-material
\def\codep@hooktheorem@preparebackref#1{%
  \codep@render@thm@preparebackref{#1}%
}%

%% @behavior B-PROOF-ADJ
% \codep@hooktheorem@end@outer{envname}
%   Outermost theorem end: serialize and arm proof adjacency.
%   Stashes the just-closed atom's prefixed key in
%   \codep@endenv@pendingclear so the cmd/end#1/after hook can
%   undefine the per-atom \codep@manuallyemitted@<key> flag once
%   the env's group has fully closed (atom-key no longer
%   resolvable from the ctx stack at that point).
%@effect immediate-write
\def\codep@hooktheorem@end@outer#1{%
  \codep@ctxpeekid\codep@thisatomid%
  \codep@hooktheorem@record{#1}%
  \codep@hooktheorem@preparebackref{#1}%
  % W05-P02: capture entitymeta with the user-declared display name as
  % print-kind; \codep@tmp@num is set by \codep@hooktheorem@record above
  % (via \codep@splitprefix on \codep@outeratom).  Kind is hardcoded
  % "theorem" (the category); print-kind is the backend display name.
  \codep@theorem@printkind@get{#1}{\codep@tmp@printkind}%
  \codep@captureentitymeta{\codep@outeratom}{theorem}%
    {\codep@tmp@num}{\codep@tmp@printkind}{}%
  \codep@teardownpara@suppress@begin{\codep@outeratom}%
  \codep@ctxpop{#1}%
  \global\advance\codep@trackeddepth by -1\relax%
  \global\advance\codep@suppressdepth by -1\relax%
  \xdef\codep@pendingresultid{\codep@thisatomid}%
  \xdef\codep@endenv@pendingclear{\codep@outeratom}%
}%

%% @behavior B-NUM-NESTED
%% @behavior B-EDGE-NESTED
%% @behavior B-EDGE-RESTATE
% \codep@hooktheorem@end{envname}
%   End-hook body: unwind replay, nested, or outer theorem state.
%@effect immediate-write
\def\codep@hooktheorem@end#1{%
  \ifcsequal{c@\codep@basecounter}{c@atom}{%
    \ifnum\codep@trackeddepth>1\relax%
      \global\advance\codep@trackeddepth by -1\relax%
      \global\advance\codep@suppressdepth by -1\relax%
    \else%
      \codep@hooktheorem@end@outer{#1}%
    \fi%
  }{%
    \global\advance\codep@replaydepth by -1\relax%
    \global\advance\codep@suppressdepth by -1\relax%
  }%
}%

% \codep@hooktheorem@afterend{envname}
%   After-end-environment hook body.  Inline backrefs are flushed
%   EARLY in cmd/end#1/before (inside the env body, in hmode, before
%   amsthm's \popQED/endmark mechanism) so "Used in" flows on the
%   same line as content; this post-env hook is a no-op for that
%   path.  For restatable re-fires (which call \theorem/\endtheorem
%   directly, bypassing \begin/\end), neither hook fires — correct,
%   since the restate guard already skipped backref queueing in the
%   cmd/end hook above.  Retained as a hook point so the theorem
%   orchestrator body stays stable across future rendering variants.
%% @implements \codep@hooktheorem
%@effect inline-material
\def\codep@hooktheorem@afterend#1{%
  \codep@render@thm@afterend{#1}%
}

% \codep@manuallyemitted@end@outer@clear
%   cmd/end#1/after hook body for tracked theorem-like envs.
%   Consumes \codep@endenv@pendingclear (populated at
%   \codep@hooktheorem@end@outer time) and undefines the
%   corresponding per-atom flag so the next outer atom of the
%   same env starts with a clean slate.  Inert during replay
%   (the stash is only populated in the non-replay branch, so
%   the replay guard is belt+suspenders) and inert at inner-env
%   end (the stash is only populated for the OUTER env's
%   \codep@hooktheorem@end@outer path, never inner).
%% @utility
%@effect state-only
\def\codep@manuallyemitted@end@outer@clear{%
  \ifnum\codep@replaydepth=0\relax%
    \ifx\codep@endenv@pendingclear\@empty\else%
      \codep@manuallyemitted@clear@key{\codep@endenv@pendingclear}%
      \global\let\codep@endenv@pendingclear\@empty%
    \fi%
  \fi%
}%

% \codep@teardownpara@suppressdepth
%   Tracks open teardown-para suppression windows.  Opened by
%   \codep@hooktheorem@end@outer (outer theorem end only); closed by
%   \codep@teardownpara@suppress@end@outer@clear at cmd/end#1/after
%   or env/#1/after.  Suppresses para/begin side effects while backend
%   end material is still being processed after theorem teardown.
%% @utility
%@effect state-only
\newcount\codep@teardownpara@suppressdepth%
\let\codep@teardownpara@pendingclear\@empty%

% \codep@teardownpara@suppress@begin{outer-atom}
%   Open one teardown-para suppression window.  Called from
%   \codep@hooktheorem@end@outer only; must not be called from
%   inner-env ends or replay paths.
%% @utility
%@effect state-only
\def\codep@teardownpara@suppress@begin#1{%
  \global\advance\codep@teardownpara@suppressdepth by 1\relax%
  \xdef\codep@teardownpara@pendingclear{#1}%
}%

% \codep@teardownpara@suppress@end@outer@clear
%   Close one teardown-para suppression window.  Outer-only and
%   positive-only: inert during replay, inert when pending-clear is
%   empty, decrements depth only when positive, always empties
%   pending-clear after consuming it.
%% @utility
%@effect state-only
\def\codep@teardownpara@suppress@end@outer@clear{%
  \ifnum\codep@replaydepth=0\relax%
    \ifx\codep@teardownpara@pendingclear\@empty\else%
      \ifnum\codep@teardownpara@suppressdepth>0\relax%
        \global\advance\codep@teardownpara@suppressdepth by -1\relax%
      \fi%
      \global\let\codep@teardownpara@pendingclear\@empty%
    \fi%
  \fi%
}%

% \codep@theorem@end@postclear
%   Combined postclear for cmd/end#1/after and env/#1/after sites.
%   Clears both the manually-emitted pending flag and the teardown-para
%   suppression window opened by \codep@hooktheorem@end@outer.
%% @utility
%@effect state-only
\def\codep@theorem@end@postclear{%
  \codep@manuallyemitted@end@outer@clear%
  \codep@teardownpara@suppress@end@outer@clear%
}%

%% ===================================================================
%% W05-XPARSE-SUBSTRATE P01: lifecycle API, descriptor, dispatcher
%% INERT until P02/P03 rewires call sites.
%% ===================================================================

% \codep@lifecycle@register@prebegin{env}{callback}
%   Register code at cmd/<env>/before without changing hook semantics.
%% @utility
%@effect state-only
\newcommand{\codep@lifecycle@register@prebegin}[2]{%
  \AddToHook{cmd/#1/before}{#2}%
}

% \codep@lifecycle@register@postbegin{env}{callback}
%   Register code at cmd/<env>/after without changing hook semantics.
%% @utility
%@effect state-only
\newcommand{\codep@lifecycle@register@postbegin}[2]{%
  \AddToHook{cmd/#1/after}{#2}%
}

% \codep@lifecycle@register@preend{env}{callback}
%   Register code at cmd/end<env>/before without changing hook semantics.
%% @utility
%@effect state-only
\newcommand{\codep@lifecycle@register@preend}[2]{%
  \AddToHook{cmd/end#1/before}{#2}%
}

% \codep@lifecycle@register@postend{env}{callback}
%   Register code at cmd/end<env>/after without changing hook semantics.
%% @utility
%@effect state-only
\newcommand{\codep@lifecycle@register@postend}[2]{%
  \AddToHook{cmd/end#1/after}{#2}%
}

% \codep@lifecycle@register@afterenv{env}{callback}
%   Register code after an environment without changing hook semantics.
%% @utility
%@effect state-only
\newcommand{\codep@lifecycle@register@afterenv}[2]{%
  \AfterEndEnvironment{#1}{#2}%
}

%% ===================================================================
%% W05-INSTALL-DISCIPLINE-CORE P01: typed installer substrate
%% INERT until later CORE items migrate call sites onto these wrappers.
%% ===================================================================
%% Install-kinds (frozen CORE enum):
%%   pretocmd              — etoolbox pre-patch
%%   apptocmd              — etoolbox post-patch
%%   AddToHook             — LaTeX2e named hook
%%   backend-hook          — package-created LaTeX hook path
%%   macro-append          — typed \g@addto@macro-shaped append
%%   theorem-name-link-wrap — amsthm-family theorem-name wrapper
%%   lifecycle-rewrap      — per-begin ntheorem-style lifecycle rewrap
%%   command-wrap          — static saved-original command wrapper
%% Lifecycle slots: pre-begin, post-begin, pre-end, post-end, after-env.
%% Effects: state-only, immediate-write, deferred-write,
%%   zero-visible-destination, inline-material.
%% Typed exception: Track-2 shipout-order write.
%% command-wrap invariants:
%%   1. save a package-owned original exactly once;
%%   2. preserve declaration mechanism;
%%   3. preserve signature (arity, star, optional/required, long, CSV);
%%   4. preserve wrapper ordering;
%%   5. replacement body references only the saved original;
%%   6. dynamic \protected\edef#2 shape is rejected/deferred.
%% See planner-w05-install-discipline-core-rev2.md
%%   §Command-wrap installer contract.

% \codep@install@slot@allow{slot}{register-name}
%   Register one lifecycle slot and its existing lifecycle register suffix.
%% @utility
%@effect state-only
\newcommand*{\codep@install@slot@allow}[2]{%
  \csgdef{codep@install@slot@#1}{#2}%
}

\codep@install@slot@allow{pre-begin}{prebegin}%
\codep@install@slot@allow{post-begin}{postbegin}%
\codep@install@slot@allow{pre-end}{preend}%
\codep@install@slot@allow{post-end}{postend}%
\codep@install@slot@allow{after-env}{afterenv}%

% \codep@install@effect@allow{effect}
%   Register one install effect as part of the CORE effect vocabulary.
%% @utility
%@effect state-only
\newcommand*{\codep@install@effect@allow}[1]{%
  \csgdef{codep@install@effect@#1}{1}%
}

\codep@install@effect@allow{state-only}%
\codep@install@effect@allow{immediate-write}%
\codep@install@effect@allow{deferred-write}%
\codep@install@effect@allow{zero-visible-destination}%
\codep@install@effect@allow{inline-material}%
\codep@install@effect@allow{track2-shipout-order-write}%

% \codep@activation@let@install{target}{active-callback}
%   Activate a package-owned aux callback inside a typed hook body.
%% @utility
%@effect state-only
\newcommand*{\codep@activation@let@install}[2]{%
  \let#1#2%
}

% \codep@install@kind@allow{install-kind}{handler-name}
%   Register one frozen install-kind and its target dispatcher suffix.
%% @utility
%@effect state-only
\newcommand*{\codep@install@kind@allow}[2]{%
  \csgdef{codep@install@kind@#1}{#2}%
}

\codep@install@kind@allow{pretocmd}{pretocmd}%
\codep@install@kind@allow{apptocmd}{apptocmd}%
\codep@install@kind@allow{AddToHook}{addtohook}%
\codep@install@kind@allow{backend-hook}{backendhook}%
\codep@install@kind@allow{macro-append}{macroappend}%
\codep@install@kind@allow{theorem-name-link-wrap}{theoremname}%
\codep@install@kind@allow{lifecycle-rewrap}{lifecyclerewrap}%
\codep@install@kind@allow{command-wrap}{commandwrap}%
\codep@install@kind@allow{dynamic-command-wrap}{dynamiccommandwrap}%
\codep@install@kind@allow{counter-alias}{counteralias}%

% \codep@install@matrix@allow{slot}{effect}
%   Mark one lifecycle slot/effect pair compatible.
%% @utility
%@effect state-only
\newcommand*{\codep@install@matrix@allow}[2]{%
  \csgdef{codep@install@effectslot@#1@#2}{1}%
}

%% Compat matrix for lifecycle slot/effect assertions.
%% Allowed:
%%   pre-begin, post-begin, pre-end, post-end, after-env
%%     × state-only
%%   pre-begin, post-begin, pre-end, post-end
%%     × immediate-write / deferred-write / inline-material
%%   pre-begin, post-begin, pre-end, post-end, after-env
%%     × zero-visible-destination
%%   after-env × the Track-2 shipout-order write typed exception
%% Forbidden:
%%   after-env × immediate-write / deferred-write / inline-material.
%%   Those effects would silently re-order writes or visible tokens after
%%   the environment's natural stream position; only the Track-2 typed
%%   exception is allowed there because its shipout-order behavior is
%%   the documented equation-reading-order contract.
\codep@install@matrix@allow{pre-begin}{state-only}%
\codep@install@matrix@allow{post-begin}{state-only}%
\codep@install@matrix@allow{pre-end}{state-only}%
\codep@install@matrix@allow{post-end}{state-only}%
\codep@install@matrix@allow{after-env}{state-only}%
\codep@install@matrix@allow{pre-begin}{immediate-write}%
\codep@install@matrix@allow{post-begin}{immediate-write}%
\codep@install@matrix@allow{pre-end}{immediate-write}%
\codep@install@matrix@allow{post-end}{immediate-write}%
\codep@install@matrix@allow{pre-begin}{deferred-write}%
\codep@install@matrix@allow{post-begin}{deferred-write}%
\codep@install@matrix@allow{pre-end}{deferred-write}%
\codep@install@matrix@allow{post-end}{deferred-write}%
\codep@install@matrix@allow{pre-begin}{zero-visible-destination}%
\codep@install@matrix@allow{post-begin}{zero-visible-destination}%
\codep@install@matrix@allow{pre-end}{zero-visible-destination}%
\codep@install@matrix@allow{post-end}{zero-visible-destination}%
\codep@install@matrix@allow{after-env}{zero-visible-destination}%
\codep@install@matrix@allow{pre-begin}{inline-material}%
\codep@install@matrix@allow{post-begin}{inline-material}%
\codep@install@matrix@allow{pre-end}{inline-material}%
\codep@install@matrix@allow{post-end}{inline-material}%
\codep@install@matrix@allow{after-env}{track2-shipout-order-write}%

% \codep@install@assert@known@slot{slot}
%   Fail fast when a lifecycle caller uses a slot outside the 5-slot lattice.
%% @utility
%@effect state-only
\newcommand*{\codep@install@assert@known@slot}[1]{%
  \ifcsdef{codep@install@slot@#1}{%
  }{%
    \PackageError{codependent}{unknown lifecycle slot #1}{%
      Expected one of pre-begin, post-begin, pre-end, post-end, after-env.}%
  }%
}

% \codep@install@assert@known@effect{effect}
%   Fail fast when an install caller uses an effect outside CORE vocabulary.
%% @utility
%@effect state-only
\newcommand*{\codep@install@assert@known@effect}[1]{%
  \ifcsdef{codep@install@effect@#1}{%
  }{%
    \PackageError{codependent}{unknown install effect #1}{%
      Expected state-only, immediate-write, deferred-write, %
      zero-visible-destination, inline-material, or the Track-2 %
      shipout-order write typed exception.}%
  }%
}

% \codep@install@assert@known@kind{install-kind}
%   Fail fast when a target caller uses a kind outside the frozen enum.
%% @utility
%@effect state-only
\newcommand*{\codep@install@assert@known@kind}[1]{%
  \ifcsdef{codep@install@kind@#1}{%
  }{%
    \PackageError{codependent}{%
      unknown install-kind #1; CORE/CONTRACT enum is frozen at 10 members}{%
      Expected pretocmd, apptocmd, AddToHook, backend-hook, macro-append, %
      theorem-name-link-wrap, lifecycle-rewrap, command-wrap, %
      dynamic-command-wrap, or counter-alias.}%
  }%
}

% \codep@install@assert@compatible{slot}{effect}
%   Enforce the lifecycle slot/effect compatibility matrix at install time.
%% @utility
%@effect state-only
\newcommand*{\codep@install@assert@compatible}[2]{%
  \ifcsdef{codep@install@effectslot@#1@#2}{%
  }{%
    \PackageError{codependent}{%
      effect #2 incompatible with slot #1; see compat matrix}{%
      The lifecycle compat matrix forbids after-env immediate/deferred %
      writes and inline material; use the typed Track-2 exception only %
      for the equation-range dispatcher.}%
  }%
}

% \codep@hook@install@register{register-name}{slot}{env}{callback}
%   Install a verified lifecycle callback with the raw primitive shape that
%   pre-typed call sites used, preserving hook order and wire-format bytes.
%% @utility
%@effect state-only
\newcommand*{\codep@hook@install@register}[4]{%
  \def\codep@install@register@prebegin{prebegin}%
  \def\codep@install@register@postbegin{postbegin}%
  \def\codep@install@register@preend{preend}%
  \def\codep@install@register@postend{postend}%
  \def\codep@install@register@afterenv{afterenv}%
  \edef\codep@install@register@current{#1}%
  \ifx\codep@install@register@current\codep@install@register@prebegin%
    \AtBeginEnvironment{#3}{#4}%
  \else\ifx\codep@install@register@current\codep@install@register@postbegin%
    \AtBeginEnvironment{#3}{#4}%
  \else\ifx\codep@install@register@current\codep@install@register@preend%
    \AtEndEnvironment{#3}{#4}%
  \else\ifx\codep@install@register@current\codep@install@register@postend%
    \codep@lifecycle@register@postend{#3}{#4}%
  \else\ifx\codep@install@register@current\codep@install@register@afterenv%
    \AfterEndEnvironment{#3}{#4}%
  \else%
    \PackageError{codependent}{lifecycle slot #2 has no register mapping}{%
      Expected \string\codep@lifecycle@register@#1\space to exist.}%
  \fi\fi\fi\fi\fi%
}

% \codep@hook@install{slot}{env-name}{effect}{callback}
%   Typed dispatcher for the five lifecycle slots.
%% @utility
%@effect state-only
\newcommand*{\codep@hook@install}[4]{%
  \codep@install@assert@known@slot{#1}%
  \codep@install@assert@known@effect{#3}%
  \codep@install@assert@compatible{#1}{#3}%
  \edef\codep@install@registername{%
    \csuse{codep@install@slot@#1}}%
  \codep@hook@install@register{\codep@install@registername}{#1}{#2}{#4}%
}

% \codep@install@settargetname{control-sequence}
%   Store a bare target control-sequence name for codep@orig@... construction.
%% @utility
%@effect state-only
\newcommand*{\codep@install@settargetname}[1]{%
  \edef\codep@install@targetname{\expandafter\@gobble\string#1}%
}

% \codep@install@saveoriginal@named{target}{orig-csname}{replacement}
%   Save a package-owned original once, then run the replacement installer.
%% @utility
%@effect state-only
\newcommand*{\codep@install@saveoriginal@named}[3]{%
  \ifcsdef{#2}{%
    \PackageWarning{codependent}{%
      typed installer already saved original for \string#1; skipping reinstall}%
  }{%
    \global\cslet{#2}#1%
    #3%
  }%
}

% \codep@install@saveoriginal@auto{target}{replacement}
%   Save target as \codep@orig@<target-name> and install replacement.
%% @utility
%@effect state-only
\newcommand*{\codep@install@saveoriginal@auto}[2]{%
  \codep@install@settargetname{#1}%
  \edef\codep@install@origname{codep@orig@\codep@install@targetname}%
  \codep@install@saveoriginal@named{#1}{\codep@install@origname}{#2}%
}

% \codep@install@ifprotectededefTF{tokens}{true}{false}
%   Detect CORE-forbidden \protected\edef in a command-wrap replacement.
%% @utility
%@effect state-only
\ExplSyntaxOn
\long\def\codep@install@ifprotectededefTF#1#2#3{%
  \tl_set:Nx \l_tmpa_tl { \tl_to_str:n {#1} }%
  \str_if_in:NnTF \l_tmpa_tl { \protected \edef } {#2} {#3}%
}
\ExplSyntaxOff

% \codep@target@install@pretocmd{target}{effect}{prepend-body}
%   Typed etoolbox pre-patch wrapper.
%% @utility
%@effect state-only
\newcommand*{\codep@target@install@pretocmd}[3]{%
  \pretocmd{#1}{#3}{}{%
    \PackageError{codependent}{pretocmd install failed for \string#1}{%
      The target could not be patched by etoolbox.}%
  }%
}

% \codep@target@install@apptocmd{target}{effect}{append-body}
%   Typed etoolbox post-patch wrapper.
%% @utility
%@effect state-only
\newcommand*{\codep@target@install@apptocmd}[3]{%
  \apptocmd{#1}{#3}{}{%
    \PackageError{codependent}{apptocmd install failed for \string#1}{%
      The target could not be patched by etoolbox.}%
  }%
}

% \codep@target@install@addtohook{hook-name}{effect}{hook-body}
%   Typed LaTeX2e named-hook wrapper.
%% @utility
%@effect state-only
\newcommand*{\codep@target@install@addtohook}[3]{%
  \AddToHook{#1}{#3}%
}

% \codep@target@install@backendhook{hook-name}{effect}{body}
%   Typed wrapper for backend-created LaTeX hook paths.  BACKENDS uses
%   this for package hook names such as keytheorems/<env>/posthead
%   and keytheorems/<env>/restated; they are ordinary l3hook names,
%   not a new install-kind and not a raw \AddToHook escape hatch.
%% @utility
%@effect state-only
\newcommand*{\codep@target@install@backendhook}[3]{%
  \AddToHook{#1}{#3}%
}

% \codep@target@install@macroappend{target}{effect}{append-body}
%   Typed macro-append scaffold.
%% @utility
%@effect state-only
\newcommand*{\codep@target@install@macroappend}[3]{%
  \g@addto@macro#1{#3}%
}

% \codep@target@install@theoremname{target}{effect}{replacement}
%   Saved-original wrapper for amsthm-family theorem-name linking.
%% @utility
%@effect state-only
\newcommand*{\codep@target@install@theoremname}[3]{%
  \ifx#1\@begintheorem%
    \codep@install@saveoriginal@named{#1}{codep@orig@begintheorem}{#3}%
  \else%
    \codep@install@saveoriginal@auto{#1}{#3}%
  \fi%
}

% \codep@target@install@lifecyclerewrap{target}{effect}{replacement}
%   Saved-original scaffold for per-begin lifecycle rewrap adapters.
%% @utility
%@effect state-only
\newcommand*{\codep@target@install@lifecyclerewrap}[3]{%
  \codep@install@saveoriginal@auto{#1}{#3}%
}

% \codep@target@install@commandwrap{target}{effect}{replacement}
%   Static saved-original command wrapper.
%% @utility
%@effect state-only
\long\def\codep@target@install@commandwrap#1#2#3{%
  \codep@install@ifprotectededefTF{#3}{%
    \PackageError{codependent}{%
      command-wrap install-kind rejects dynamic \string\protected\string\edef%
      \space target shape}{%
      Dynamic saved-original wrappers are deferred to %
      W05-INSTALL-DISCIPLINE-CONTRACT.}%
  }{%
    \codep@install@saveoriginal@auto{#1}{#3}%
  }%
}

% \codep@target@install@dynamiccommandwrap{target}{effect}{replacement}
%   Dynamic saved-body command wrapper for \protected\edef target installs.
%% @utility
%@effect state-only
\long\def\codep@target@install@dynamiccommandwrap#1#2#3{%
  \codep@install@settargetname{#1}%
  \cslet{codep@body@\codep@install@targetname}#1%
  \protected\edef#1{#3}%
}

% \codep@target@install{install-kind}{target}{effect}{replacement-body}
%   Typed dispatcher for target-level installs.
%% @utility
%@effect state-only
\long\def\codep@target@install#1#2#3#4{%
  \codep@install@assert@known@kind{#1}%
  \codep@install@assert@known@effect{#3}%
  \edef\codep@install@handlername{%
    \csuse{codep@install@kind@#1}}%
  \ifcsdef{codep@target@install@\codep@install@handlername}{%
    \csuse{codep@target@install@\codep@install@handlername}%
      {#2}{#3}{#4}%
  }{%
    \PackageError{codependent}{install-kind #1 dispatch drift}{%
      Kind passed enum assertion but has no dispatcher branch.}%
  }%
}

% \codep@counter@alias@install{base-counter}{atom-counter}
%   Alias a user-visible counter register and display macro to atom counter.
%% @utility
%@effect state-only
\newcommand*{\codep@counter@alias@install}[2]{%
  \csletcs{c@#1}{c@#2}%
  \csletcs{the#1}{the#2}%
}

% \codep@proof@install@heading{target-cs}{effect}{prepend}{failure}
%   Patch proof's generated optional-heading body under catcode-12 #.
%   target-cs -- expandable control-sequence expression, e.g.
%     \csname\string\proof\endcsname
%   effect -- install effect, usually inline-material
%   prepend -- body to prepend to the proof heading macro
%   failure -- diagnostic body used if etoolbox cannot patch the target
%% @utility
%@effect inline-material
\long\def\codep@proof@install@heading#1#2#3#4{%
  \codep@install@assert@known@effect{#2}%
  \expandafter\pretocmd#1{#3}{}{#4}%
}

% \codep@envtrack@config@write{env}{field}{value}
%   Store a token-list descriptor field keyed by environment and field.
%% @utility
%@effect state-only
\newcommand*{\codep@envtrack@config@write}[3]{%
  \csdef{codep@envtrack@cfg@#1@#2}{#3}%
}

% \codep@envtrack@config@read{env}{field}{cs}
%   Bind a control sequence to a stored env-track descriptor field.
%% @utility
%@effect state-only
\newcommand*{\codep@envtrack@config@read}[3]{%
  \letcs#3{codep@envtrack@cfg@#1@#2}%
}

% \codep@envtrack@ifkeytheoremsTF{env}{true}{false}
%   Detect keytheorems envs after \newkeytheorem has keyified them.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@ifkeytheoremsTF}[3]{%
  \@ifpackageloaded{keytheorems}{%
    \ifcsdef{keythms_orig_#1}{%
      #2%
    }{%
      #3%
    }%
  }{#3}%
}

% \codep@envtrack@iftcolorboxTF{env}{true}{false}
%   Detect tcolorbox-created environments with saved option rows.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@iftcolorboxTF}[3]{%
  \@ifpackageloaded{tcolorbox}{%
    \ifcsdef{tcb@opt@#1}{%
      #2%
    }{%
      #3%
    }%
  }{#3}%
}

% \codep@envtrack@ifxparseTF{env}{true}{false}
%   True for xparse theorem backends that need resolver validation.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@ifxparseTF}[3]{%
  \codep@envtrack@ifkeytheoremsTF{#1}{#2}{%
    \codep@envtrack@iftcolorboxTF{#1}{#2}{#3}%
  }%
}

% \codep@envtrack@ifnumberedresolverTF{env}{true}{false}
%   Check whether an xparse theorem exposes a numbered counter resolver.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@ifnumberedresolverTF}[3]{%
  \codep@envtrack@ifkeytheoremsTF{#1}{%
    \ifcsdef{c@#1}{%
      #2%
    }{%
      #3%
    }%
  }{%
    \codep@envtrack@iftcolorboxTF{#1}{%
      \ifcsdef{tcb@cnt@#1}{%
        #2%
      }{%
        #3%
      }%
    }{#2}%
  }%
}

% \codep@envtrack@missingresolver{env}{backend}
%   Silent no-track for unnumbered/starred envs across all backends.
%   Temporary parity behavior: tcolorbox and keytheorems unnumbered/starred
%   envs now match the amsthm/ntheorem silent path. A future design wave
%   will decide whether these envs should track to .cdp and render.
%   See: project_unnumbered_starred_tracking_future_decision.md
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@missingresolver}[2]{}%

% \codep@envtrack@resolvecounter{env}{cs}
%   Resolve an env name to the counter name codependent should alias.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@resolvecounter}[2]{%
  \let#2\@empty%
  \codep@envtrack@ifkeytheoremsTF{#1}{%
    \ifcsdef{c@#1}{%
      \edef#2{#1}%
    }{%
      \codep@envtrack@missingresolver{#1}{keytheorems}%
    }%
  }{%
    \codep@envtrack@iftcolorboxTF{#1}{%
      \ifcsdef{tcb@cnt@#1}{%
        \edef#2{tcb@cnt@#1}%
      }{%
        \codep@envtrack@missingresolver{#1}{tcolorbox}%
      }%
    }{%
      \ifcsdef{c@#1}{%
        \edef#2{#1}%
      }{}%
    }%
  }%
}

% \codep@envtrack@write@cmdhook{env}
%   Descriptor row: exactly {strategy, quirks-key}; no effect field.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@write@cmdhook}[1]{%
  \codep@envtrack@config@write{#1}{strategy}{cmd-hook-observable}%
  \codep@envtrack@config@write{#1}{quirks-key}{none}%
}

% \codep@envtrack@write@tcolorbox{env}
%   Descriptor row for tcolorbox theorem quirks: phantom canary and
%   already-stepped counter capture are consumed by the P02 adapter.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@write@tcolorbox}[1]{%
  \codep@envtrack@config@write{#1}{strategy}{env-hook-observable}%
  \codep@envtrack@config@write{#1}{quirks-key}{tcolorbox-theorem}%
}

% \codep@envtrack@write@keytheorems{env}
%   Descriptor row for keytheorems quirks: posthead anchor capture,
%   restated suppression, and store* hard-error are consumed by P03.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@write@keytheorems}[1]{%
  \codep@envtrack@config@write{#1}{strategy}{env-hook-observable}%
  \codep@envtrack@config@write{#1}{quirks-key}{keytheorems}%
}

% \codep@envtrack@resolve{env}
%   Write the two-field descriptor row selected by backend probes.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@resolve}[1]{%
  \codep@envtrack@ifkeytheoremsTF{#1}{%
    \codep@envtrack@write@keytheorems{#1}%
  }{%
    \codep@envtrack@iftcolorboxTF{#1}{%
      \codep@envtrack@write@tcolorbox{#1}%
    }{%
      \codep@envtrack@write@cmdhook{#1}%
    }%
  }%
}

% \codep@strategy@cmdhookobservable
%   Strategy ID for the legacy command-hook-observable theorem path.
%% @utility
\def\codep@strategy@cmdhookobservable{cmd-hook-observable}%

% \codep@strategy@envhookobservable
%   Strategy ID for xparse-compatible env/<env>/begin+end observation.
%% @utility
\def\codep@strategy@envhookobservable{env-hook-observable}%

% \codep@quirks@tcolorboxtheorem
%   Quirks-key row for tracked tcolorbox \newtcbtheorem environments.
%% @utility
\def\codep@quirks@tcolorboxtheorem{tcolorbox-theorem}%

% \codep@quirks@keytheorems
%   Quirks-key row for tracked keytheorems environments.
%% @utility
\def\codep@quirks@keytheorems{keytheorems}%

% keytheorems adapter state.
%% @utility
\newif\ifcodep@keythms@begun
%% @utility
\newif\ifcodep@keythms@begintracked
%% @utility
\newif\ifcodep@keythms@storestarerror
%% @utility
\newif\ifcodep@keythms@materialized

% tcolorbox theorem adapter state.
%% @utility
\protected\def\codep@tcb@canary{}%
%% @utility
\def\codep@tcb@stop{\codep@tcb@stop}%
%% @utility
\let\codep@tcb@armedenv\@empty
%% @utility
\newif\ifcodep@tcb@afteroptionsinstalled
%% @utility
\newif\ifcodep@tcb@begun
%% @utility
\newif\ifcodep@tcb@enabled
%% @utility
\newif\ifcodep@tcb@materialized
%% @utility
\newif\ifcodep@tcb@thmwrapinstalled

% \codep@tcb@resetboxstate
%   Clear one-box tcolorbox adapter state after env end or disablement.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@resetboxstate{%
  \global\codep@tcb@begunfalse%
  \global\codep@tcb@enabledfalse%
  \global\codep@tcb@materializedfalse\global\codep@tcb@titlefoundfalse%
  \global\let\codep@tcb@armedenv\@empty\global\let\codep@tcb@printkind\@empty%
  \global\let\codep@thmwrap@activeenv\@empty%
}%

% \codep@tcb@begin{env}
%   Per-env typed pretocmd body: arm state and inject canary-bearing
%   tcolorbox phantom material before user options can clear it.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@begin#1{%
  \codep@closeparagraphifopen%
  \global\let\codep@pendingresultid\@empty%
  \codep@hooktheorem@begin{#1}%
  \global\codep@tcb@beguntrue%
  \global\codep@tcb@enabledfalse%
  \global\codep@tcb@materializedfalse\global\codep@tcb@titlefoundfalse%
  \global\let\codep@tcb@printkind\@empty\gdef\codep@tcb@armedenv{#1}%
  \tcbset{phantom={%
    \codep@tcb@materialize{#1}%
    \codep@tcb@canary}}%
}%

% \codep@tcb@ifcanaryTF{true}{false}
%   Test whether the protected canary token survived in \kvtcb@phantom
%   without expanding user phantom material.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@ifcanaryTF#1#2{%
  \def\codep@tcb@ifcanaryTF@scan##1\codep@tcb@canary##2%
      \codep@tcb@stop{%
    \def\codep@tmp@tail{##2}%
    \ifx\codep@tmp@tail\@empty%
      #2%
    \else%
      #1%
    \fi%
  }%
  \expandafter\codep@tcb@ifcanaryTF@scan\kvtcb@phantom%
    \codep@tcb@canary\codep@tcb@stop%
}%

% \codep@tcb@disable@thisbox
%   Loss-of-canary path: no atom, no name link, no hard error.
%% @behavior B-COMPAT-TCOLORBOX-THEOREM
%@effect state-only
\def\codep@tcb@disable@thisbox{%
  \PackageWarning{codependent}{%
    Tracked tcolorbox theorem '\codep@tcb@armedenv' cleared\space%
    codependent phantom material (nophantom or another\space%
    phantom-clearing option); no codependent atom or appendix\space%
    theorem-name link will be emitted for this box}%
  \global\codep@tcb@enabledfalse%
  \global\codep@tcb@materializedfalse%
  \global\let\codep@tcb@armedenv\@empty%
  \global\let\codep@thmwrap@activeenv\@empty%
}%

% \codep@tcb@afteroptions@maybe
%   Private tcolorbox after-options hook callback.  It observes the
%   effect of nophantom without expanding the phantom token list.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@afteroptions@maybe{%
  \ifx\codep@tcb@armedenv\@empty\else%
    \codep@tcb@ifcanaryTF{%
      \global\codep@tcb@enabledtrue\codep@tcb@captureprintkind{\codep@tcb@armedenv}%
      \global\let\codep@tcb@armedenv\@empty%
    }{%
      \codep@tcb@disable@thisbox%
    }%
  \fi%
}%

% \codep@tcb@capturecounter{env}
%   Capture tcolorbox's already-stepped theorem display number.  The first
%   edef asks \thetcbcounterof for the env display macro; the second expands
%   that display macro to digits without stepping any counter.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@capturecounter#1{%
  \edef\codep@tmp@tcbcounter{\thetcbcounterof{#1}}%
  \edef\codep@tmp@tcbcounter{\codep@tmp@tcbcounter}%
}%

% \codep@tcb@materialize{env}
%   Phantom-time atom materialization for a tracked tcolorbox theorem.
%% @implements \codep@hooktheorem
%@effect immediate-write
\def\codep@tcb@materialize#1{%
  \ifcodep@tcb@enabled%
    \ifcodep@tcb@materialized%
    \else%
      \global\codep@tcb@materializedtrue%
      \ifnum\codep@trackeddepth=1\relax%
        \codep@ctxpeekid\codep@thisatomid%
        \ifx\codep@thisatomid\@empty\else%
          \codep@atomgetkey{\codep@thisatomid}{\codep@tmp@existingkey}%
          \ifx\codep@tmp@existingkey\@empty%
            \codep@tcb@capturecounter{#1}%
            \xdef\codep@outeratom{#1:\codep@tmp@tcbcounter}%
            \codep@atomsetkey{\codep@thisatomid}{\codep@outeratom}%
          \else%
            \xdef\codep@outeratom{\codep@tmp@existingkey}%
          \fi%
          \codep@hooktheorem@writeanchorandpage%
        \fi%
      \fi%
    \fi%
  \fi%
}%

% \codep@tcb@end@outer{env}
%   Record/render a tcolorbox theorem atom while leaving suppression and
%   ctx stack active until env/<env>/after closes the box.
%% @implements \codep@hooktheorem
%@effect inline-material
\def\codep@tcb@end@outer#1{%
  \codep@ctxpeekid\codep@thisatomid%
  \codep@hooktheorem@record{#1}%
  \codep@hooktheorem@preparebackref{#1}\codep@theorem@printkind@get{#1}{\codep@tmp@printkind}%
  \codep@captureentitymeta{\codep@outeratom}{theorem}%
    {\codep@tmp@num}{\codep@tmp@printkind}{}%
  \xdef\codep@pendingresultid{\codep@thisatomid}%
  \xdef\codep@endenv@pendingclear{\codep@outeratom}%
}%

% \codep@tcb@end{env}
%   Env-end renderer for materialized tcolorbox theorem atoms.
%% @implements \codep@hooktheorem
%@effect inline-material
\def\codep@tcb@end#1{%
  \ifcodep@tcb@materialized%
    \ifcsequal{c@\codep@basecounter}{c@atom}{%
      \ifnum\codep@trackeddepth>1\relax%
      \else%
        \codep@tcb@end@outer{#1}%
      \fi%
    }{}%
  \fi%
}%

% \codep@tcb@after{env}
%   Pop/cancel tcolorbox theorem state after the box closing material.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@after#1{%
  \ifcodep@tcb@begun%
    \ifcsequal{c@\codep@basecounter}{c@atom}{%
      \ifnum\codep@trackeddepth>1\relax%
        \global\advance\codep@trackeddepth by -1\relax%
        \global\advance\codep@suppressdepth by -1\relax%
      \else%
        \codep@ctxpop{#1}%
        \global\advance\codep@trackeddepth by -1\relax%
        \global\advance\codep@suppressdepth by -1\relax%
        \ifcodep@tcb@materialized%
          \codep@manuallyemitted@end@outer@clear%
        \else%
          \global\let\codep@pendingresultid\@empty%
        \fi%
      \fi%
    }{%
      \global\advance\codep@replaydepth by -1\relax%
      \global\advance\codep@suppressdepth by -1\relax%
    }%
  \fi%
  \codep@tcb@resetboxstate%
}%

% \codep@tcb@afteroptions@install
%   Idempotently append the tcolorbox after-options canary callback.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@afteroptions@install{%
  \ifcodep@tcb@afteroptionsinstalled%
  \else%
    \ifcsundef{tcb@afteroptions@hook}{%
      \PackageWarning{codependent}{%
        tcolorbox theorem adapter could not find\space%
        \string\tcb@afteroptions@hook; nophantom canary disabled}%
    }{%
      \global\codep@tcb@afteroptionsinstalledtrue%
      \codep@target@install{macro-append}{\tcb@afteroptions@hook}%
        {state-only}{\codep@tcb@afteroptions@maybe}%
    }%
  \fi%
}%

% \codep@tcb@thmwrap@title{name}{number}{description}
%   Wrapper body for tcolorbox theorem headings.
%% @implements \codep@thmwrap@install
%@effect inline-material
\def\codep@tcb@thmwrap@title#1#2#3{%
  \codep@thmwrap@wrapname{#1}{\codep@tmp@wrappedthmname}%
  \csuse{codep@orig@__tcobox_theo_title:nnn}%
    {\codep@tmp@wrappedthmname}{#2}{#3}%
  \global\let\codep@thmwrap@activeenv\@empty%
}%

% \codep@tcb@thmwrap@install@target{target-cs}
%   Install the tcolorbox theorem-title wrapper through the CORE kind.
%% @implements \codep@thmwrap@install
%@effect inline-material
\def\codep@tcb@thmwrap@install@target#1{%
  \codep@target@install{theorem-name-link-wrap}{#1}{inline-material}{%
    \def#1##1##2##3{%
      \codep@tcb@thmwrap@title{##1}{##2}{##3}%
    }%
  }%
}%

% \codep@tcb@thmwrap@install
%   Install tcolorbox theorem-name forward linking once.
%% @behavior B-COMPAT-TCOLORBOX-THEOREM
%% @behavior B-LINK-APPENDIX-BIDIR
%@effect inline-material
\def\codep@tcb@thmwrap@install{%
  \ifcodep@tcb@thmwrapinstalled%
  \else%
    \ifcsundef{__tcobox_theo_title:nnn}{%
      \PackageWarning{codependent}{%
        tcolorbox theorem adapter could not find the theorem title\space%
        renderer; appendix theorem-name links disabled for tcolorbox}%
    }{%
      \global\codep@tcb@thmwrapinstalledtrue%
      \expandafter\codep@tcb@thmwrap@install@target%
        \csname __tcobox_theo_title:nnn\endcsname%
    }%
  \fi%
}%

% \codep@tcb@pretocmd@install@target{target-cs}{env}
%   Install the per-env tcolorbox begin adapter through typed pretocmd.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@pretocmd@install@target#1#2{%
  \codep@target@install{pretocmd}{#1}{state-only}{%
    \codep@tcb@begin{#2}}%
}%

% \codep@tcb@env@install{env}
%   Per tracked tcolorbox theorem environment install surface.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@env@install#1{%
  \ifcsdef{codep@tcb@patched@#1}{%
  }{%
    \ifcsundef{#1}{%
      \PackageError{codependent}{%
        Tracked tcolorbox theorem environment '#1' is undefined}{%
        Define the \string\newtcbtheorem\space environment before%
        \MessageBreak calling \string\codeptrack.}%
    }{%
      \expandafter\codep@tcb@pretocmd@install@target%
        \csname #1\endcsname{#1}%
      \codep@target@install{AddToHook}{env/#1/end}{inline-material}{%
        \codep@tcb@end{#1}}%
      \codep@target@install{AddToHook}{env/#1/after}{state-only}{%
        \codep@tcb@after{#1}}%
      \csgdef{codep@tcb@patched@#1}{1}%
    }%
  }%
}%

% \codep@hooktheorem@tcolorbox{env}
%   Quirks-row installer for tracked \newtcbtheorem environments.
%% @behavior B-COMPAT-TCOLORBOX-THEOREM
%% @behavior B-NUM-SEQ
%% @behavior B-LINK-APPENDIX-BIDIR
%@effect state-only
\def\codep@hooktheorem@tcolorbox#1{%
  \codep@tcb@afteroptions@install%
  \codep@tcb@thmwrap@install%
  \codep@tcb@env@install{#1}%
}%

% \codep@keythms@resetstate
%   Clear one-occurrence keytheorems adapter state.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@keythms@resetstate{%
  \global\codep@keythms@begunfalse%
  \global\codep@keythms@begintrackedfalse%
  \global\codep@keythms@storestarerrorfalse%
  \global\codep@keythms@materializedfalse%
  \global\let\codep@thmwrap@activeenv\@empty%
}%

% \codep@keythms@ifstorestarTF{true}{false}
%   Test keytheorems' private store* tl after key parsing.
%% @implements \codep@hooktheorem
%@effect state-only
\ExplSyntaxOn
\def\codep@keythms@ifstorestarTF#1#2{%
  \cs_if_exist:NTF \l__keythms_thmuse_storereversed_tl%
    {%
      \tl_if_empty:NTF \l__keythms_thmuse_storereversed_tl%
        {#2}%
        {#1}%
    }%
    {#2}%
}%
\ExplSyntaxOff

% \codep@keythms@ifrestatingTF{true}{false}
%   Prefer keytheorems' public restating predicate, with private fallback.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@keythms@ifrestatingTF#1#2{%
  \ifcsundef{IfRestatingTF}{%
    \ifcsundef{keythms_if_restating:TF}{#2}{%
      \csuse{keythms_if_restating:TF}{#1}{#2}}%
  }{%
    \IfRestatingTF{#1}{#2}%
  }%
}%

% \codep@keythms@storestarunsupported{env}
%   Visible unsupported boundary for tracked keytheorems store*.
%% @behavior B-COMPAT-KEYTHEOREMS-STORESTAR
%@effect state-only
\def\codep@keythms@storestarunsupported#1{%
  \ifcodep@keythms@storestarerror%
  \else%
    \global\codep@keythms@storestarerrortrue%
    \global\let\codep@thmwrap@activeenv\@empty%
    \PackageError{codependent}%
      {keytheorems store* not yet supported for tracked environments\MessageBreak%
       Use store=... instead, or remove tracking. W06 roadmap:\space%
       project_keytheorems_storestar_future_micro_wave.md}%
      {Full store* support is planned as a future micro-wave.}%
  \fi%
}%

% \codep@keythms@begin{env}
%   Env-begin phase: allocate/arm only; posthead captures anchor/page.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@keythms@begin#1{%
  \global\codep@keythms@beguntrue%
  \global\codep@keythms@storestarerrorfalse%
  \global\codep@keythms@materializedfalse%
  \ifcsequal{c@\codep@basecounter}{c@atom}{%
    \global\codep@keythms@begintrackedtrue%
  }{%
    \global\codep@keythms@begintrackedfalse%
  }%
  \codep@hooktheorem@begin{#1}%
}%

% \codep@keythms@prehead{env}
%   Early store* gate after key parsing and before theorem heading emission.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@keythms@prehead#1{%
  \codep@keythms@ifstorestarTF{%
    \codep@keythms@storestarunsupported{#1}%
  }{}%
}%

% \codep@keythms@materialize{env}
%   Posthead phase: derive key and snapshot theorem-scoped anchor/page.
%% @behavior B-COMPAT-KEYTHEOREMS
%@effect immediate-write
\def\codep@keythms@materialize#1{%
  \ifnum\codep@trackeddepth=1\relax%
    \codep@hooktheorem@derivekey{#1}%
    \codep@hooktheorem@writeanchorandpage%
    \global\codep@keythms@materializedtrue%
  \fi%
  \global\let\codep@thmwrap@activeenv\@empty%
}%

% \codep@keythms@posthead@skip
%   Shared no-write posthead cleanup for store* and ordinary replays.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@keythms@posthead@skip{%
  \global\let\codep@thmwrap@activeenv\@empty%
  \ifcodep@keythms@begun\else%
    \codep@keythms@resetstate%
  \fi%
}%

% \codep@keythms@posthead{env}
%   Backend posthead phase for original keytheorems occurrences only.
%% @implements \codep@hooktheorem
%@effect immediate-write
\def\codep@keythms@posthead#1{%
  \ifcodep@keythms@storestarerror%
    \codep@keythms@posthead@skip%
  \else%
    \codep@keythms@ifstorestarTF{%
      \codep@keythms@storestarunsupported{#1}%
      \codep@keythms@posthead@skip%
    }{%
      \codep@keythms@ifrestatingTF{%
        \codep@keythms@posthead@skip%
      }{%
        \codep@keythms@materialize{#1}%
      }%
    }%
  \fi%
}%

% \codep@keythms@cancel{env}
%   Unwind begin-time state after a store* error without record/render writes.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@keythms@cancel#1{%
  \ifcodep@keythms@begun%
    \ifcodep@keythms@begintracked%
      \ifnum\codep@trackeddepth>1\relax%
        \global\advance\codep@trackeddepth by -1\relax%
        \global\advance\codep@suppressdepth by -1\relax%
      \else\ifnum\codep@trackeddepth>0\relax%
        \codep@ctxpop{#1}%
        \global\advance\codep@trackeddepth by -1\relax%
        \global\advance\codep@suppressdepth by -1\relax%
        \global\let\codep@pendingresultid\@empty%
      \fi\fi%
    \else%
      \ifnum\codep@replaydepth>0\relax%
        \global\advance\codep@replaydepth by -1\relax%
        \global\advance\codep@suppressdepth by -1\relax%
      \fi%
    \fi%
  \fi%
}%

% \codep@keythms@end{env}
%   Env-end phase: normal record/render/pop unless store* error fired.
%% @implements \codep@hooktheorem
%@effect inline-material
\def\codep@keythms@end#1{%
  \ifcodep@keythms@storestarerror%
    \codep@keythms@cancel{#1}%
  \else%
    \codep@hooktheorem@end{#1}%
  \fi%
  \codep@keythms@resetstate%
}%

% \codep@keythms@restated{env}
%   State-only signal for keytheorems ordinary replay suppression.
%% @behavior B-COMPAT-KEYTHEOREMS
%@effect state-only
\def\codep@keythms@restated#1{%
  \global\let\codep@thmwrap@activeenv\@empty%
  \codep@keythms@ifstorestarTF{}{%
    \advance\codep@suppressdepth by 1\relax%
  }%
}%

% \codep@keythms@env@install{env}
%   Per tracked keytheorems environment install surface.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@keythms@env@install#1{%
  \ifcsdef{codep@keythms@patched@#1}{%
  }{%
    \codep@target@install{AddToHook}{env/#1/begin}{state-only}{%
      \codep@keythms@begin{#1}}%
    \codep@target@install{backend-hook}{keytheorems/#1/prehead}{state-only}{%
      \codep@keythms@prehead{#1}}%
    \codep@target@install{backend-hook}{keytheorems/#1/posthead}%
      {immediate-write}{\codep@keythms@posthead{#1}}%
    \codep@target@install{backend-hook}{keytheorems/#1/restated}{state-only}{%
      \codep@keythms@restated{#1}}%
    \codep@target@install{AddToHook}{env/#1/end}{inline-material}{%
      \codep@keythms@end{#1}}%
    \codep@target@install{AddToHook}{env/#1/after}{state-only}{%
      \codep@theorem@end@postclear}%
    \csgdef{codep@keythms@patched@#1}{1}%
  }%
}%

% \codep@hooktheorem@keytheorems{env}
%   Quirks-row installer for tracked keytheorems environments.
%% @behavior B-COMPAT-KEYTHEOREMS
%% @behavior B-NUM-SEQ
%% @behavior B-LINK-APPENDIX-BIDIR
%@effect state-only
\def\codep@hooktheorem@keytheorems#1{%
  \codep@keythms@env@install{#1}%
}%

% \codep@hooktheorem@envhookobservable{env}
%   Register begin allocation and end record/render/pop through env hooks.
%% @implements \codep@hooktheorem
%@effect state-only
\newcommand*{\codep@hooktheorem@envhookobservable}[1]{%
  \codep@envtrack@config@read{#1}{quirks-key}{\codep@tmp@quirks}%
  \ifx\codep@tmp@quirks\codep@quirks@tcolorboxtheorem%
    \codep@hooktheorem@tcolorbox{#1}%
  \else\ifx\codep@tmp@quirks\codep@quirks@keytheorems%
    \codep@hooktheorem@keytheorems{#1}%
  \else%
    \codep@target@install{AddToHook}{env/#1/begin}{state-only}{%
      \codep@hooktheorem@begin{#1}}%
    \codep@target@install{AddToHook}{env/#1/end}{immediate-write}{%
      \codep@hooktheorem@end{#1}}%
    \codep@target@install{AddToHook}{env/#1/after}{state-only}{%
      \codep@theorem@end@postclear}%
  \fi\fi%
}

% \codep@envtrack@dispatch{env}
%   Route an env through its configured env-track strategy.
%% @utility
%@effect state-only
\newcommand*{\codep@envtrack@dispatch}[1]{%
  \codep@envtrack@config@read{#1}{strategy}{\codep@tmp@strategy}%
  \ifx\codep@tmp@strategy\codep@strategy@cmdhookobservable%
    \codep@hooktheorem{#1}%
  \else\ifx\codep@tmp@strategy\codep@strategy@envhookobservable%
    \codep@hooktheorem@envhookobservable{#1}%
  \else%
    \PackageError{codependent}{Unknown env-track strategy for #1}{%
      Expected strategy='cmd-hook-observable' or 'env-hook-observable'.%
      \MessageBreak Got something else or unset; did \string\codeptrack%
      \space run before dispatch?}%
  \fi\fi%
}

% Thin orchestrator: wire the named helpers into the five hook points.
% Fifth hook (cmd/end#1/after) clears any per-atom
% \codep@manuallyemitted@<key> flag set by an inline
% \codepbackrefs call inside the env body; see the
% \codep@manuallyemitted@end@outer@clear helper above.
%% @behavior B-NUM-SEQ
%% @behavior B-PROOF-ADJ
%@effect state-only
\newcommand*{\codep@hooktheorem}[1]{%
  \codep@lifecycle@register@prebegin{#1}{\codep@hooktheorem@begin{#1}}%
  \codep@lifecycle@register@postbegin{#1}{\codep@hooktheorem@after{#1}}%
  \codep@lifecycle@register@preend{#1}{\codep@hooktheorem@end{#1}}%
  \codep@lifecycle@register@afterenv{#1}{\codep@hooktheorem@afterend{#1}}%
  \codep@lifecycle@register@postend{#1}{\codep@theorem@end@postclear}%
}

%% @implements \codep@hooktheorem
% \codep@thmwrap@deriveactivekey
%   Derive the current tracked theorem key at \@begintheorem time.
%@effect state-only
\def\codep@thmwrap@deriveactivekey{%
  \ifx\codep@thmwrap@activeenv\@empty\else%
    \expandafter\codep@hooktheorem@derivekey%
      \expandafter{\codep@thmwrap@activeenv}%
  \fi%
}%

%% @behavior B-LINK-APPENDIX-BIDIR
% \codep@thmwrap@wrapname{name}{macro}
%   Conditionally wrap a theorem heading name with an appendix link.
%@effect inline-material
\def\codep@thmwrap@wrapname#1#2{%
  \def#2{#1}%
  \ifx\codep@thmwrap@activeenv\@empty\else%
    \ifnum\codep@replaydepth=0\relax%
      \ifnum\codep@trackeddepth=1\relax%
        \codep@getcurrentatomkey\codep@tmp@wrapkey%
        \ifx\codep@tmp@wrapkey\@empty\else%
          \ifbool{codep@appendix}{%
            \@ifpackageloaded{hyperref}{%
              \codep@graph@hasrefs{\codep@tmp@wrapkey}{%
                \edef\codep@tmp@wrapdest{%
                  codep-appendix:\codep@tmp@wrapkey}%
                \expandafter\codep@thmwrap@wrapname@withdest%
                  \expandafter{\codep@tmp@wrapdest}{#1}{#2}%
              }{}%
            }{}%
          }{}%
        \fi%
      \fi%
    \fi%
  \fi%
}%

%% @behavior B-LINK-APPENDIX-BIDIR
% \codep@thmwrap@wrapname@withdest{dest}{name}{macro}
%   Snapshot a resolved destination into the deferred theorem name tokens.
%@effect inline-material
\def\codep@thmwrap@wrapname@withdest#1#2#3{%
  \def#3{\hyperlink{#1}{#2}}%
}%

%% @behavior B-LINK-APPENDIX-BIDIR
% \codep@thmwrap@install
%   Install the amsthm-family \@begintheorem name-link shim once.
%@effect inline-material
\def\codep@thmwrap@install{%
  \ifcsundef{@begintheorem}{}{%
    \codep@target@install{theorem-name-link-wrap}{\@begintheorem}{inline-material}{%
      \def\@begintheorem##1##2[##3]{%
        \codep@thmwrap@deriveactivekey%
        \codep@thmwrap@wrapname{##1}{\codep@tmp@wrappedthmname}%
        \expandafter\codep@orig@begintheorem\expandafter{%
          \codep@tmp@wrappedthmname}{##2}[##3]%
      }%
    }%
  }%
}%

%% @behavior B-LINK-APPENDIX-BIDIR
% \codep@thmwrap@install@eventually
%   Install immediately when amsthm is loaded, else retry at begin-document.
%@effect inline-material
\def\codep@thmwrap@install@eventually{%
  \@ifpackageloaded{amsthm}{%
    \codep@thmwrap@install%
  }{%
    \AtBeginDocument{%
      \@ifpackageloaded{amsthm}{\codep@thmwrap@install}{}%
    }%
  }%
}%

%% @behavior B-LINK-APPENDIX-BIDIR
% \codep@ntheorem@thmwrap@rewrap
%   Per ntheorem theorem begin, locally wrap the active style's two heading
%   emitters.  ntheorem refreshes \@begintheorem/\@opargbegintheorem from the
%   active style before every \@thm call, so this must not be a one-shot shim.
%@effect inline-material
\def\codep@ntheorem@thmwrap@rewrap{%
  \let\codep@orig@ntheorem@begintheorem\@begintheorem%
  \let\codep@orig@ntheorem@opargbegintheorem\@opargbegintheorem%
  \def\@begintheorem##1##2{%
    \codep@thmwrap@deriveactivekey%
    \codep@thmwrap@wrapname{##1}{\codep@tmp@wrappedthmname}%
    \expandafter\codep@orig@ntheorem@begintheorem\expandafter{%
      \codep@tmp@wrappedthmname}{##2}%
  }%
  \def\@opargbegintheorem##1##2##3{%
    \codep@thmwrap@deriveactivekey%
    \codep@thmwrap@wrapname{##1}{\codep@tmp@wrappedthmname}%
    \expandafter\codep@orig@ntheorem@opargbegintheorem\expandafter{%
      \codep@tmp@wrappedthmname}{##2}{##3}%
  }%
}%

%% @behavior B-LINK-APPENDIX-BIDIR
% \codep@ntheorem@thmwrap@install
%   Install the ntheorem lifecycle rewrap once around \@thm.
%@effect inline-material
\def\codep@ntheorem@thmwrap@install{%
  \ifcsundef{@thm}{}{%
    \codep@target@install{lifecycle-rewrap}{\@thm}{inline-material}{%
      \def\@thm##1##2##3{%
        \codep@ntheorem@thmwrap@rewrap%
        \codep@orig@@thm{##1}{##2}{##3}%
      }%
    }%
  }%
}%

%% @behavior B-LINK-APPENDIX-BIDIR
% \codep@ntheorem@thmwrap@install@eventually
%   Install immediately when ntheorem is loaded, else retry at begin-document.
%@effect inline-material
\def\codep@ntheorem@thmwrap@install@eventually{%
  \@ifpackageloaded{ntheorem}{%
    \codep@ntheorem@thmwrap@install%
  }{%
    \AtBeginDocument{%
      \@ifpackageloaded{ntheorem}{\codep@ntheorem@thmwrap@install}{}%
    }%
  }%
}%

% \codep@hookproof
%   Install hooks for the proof environment.
%   When proofs=on (default), adjacent proofs inherit the
%   preceding theorem's atom number with a star suffix (e.g.
%   "2.1*").  Non-adjacent proofs (no preceding theorem, or
%   an intervening paragraph) fall back to their own atom
%   number with a warning (if proof-warnings=on).
%   Standalone proofs defer margin emission to para/begin so
%   the number appears on the "Proof." line, not on a
%   separate line.
%   Delegates to:
%     \codep@hookproof@begin     — begin dispatch
%     \codep@proof@standalone    — non-adjacent proof path
%     \codep@proof@adjacent      — adjacent proof path
%     \codep@hookproof@end       — end cleanup
%     \codep@hookproof@afterend  — block/margin flush
%% @behavior B-PROOF-ADJ
%% @behavior B-PROOF-NONADJ
%@effect state-only
\newcommand*{\codep@hookproof}{%
  \ifcsundef{proof}{}{%
    \codep@hook@install{pre-begin}{proof}{state-only}{\codep@hookproof@begin}%
    \codep@hook@install{pre-end}{proof}{state-only}{\codep@hookproof@end}%
    \codep@hook@install{after-env}{proof}{state-only}{\codep@hookproof@afterend}%
  }%
}%

% \codep@autoproofof@stop
%   Sentinel token for proof-heading scanner termination.
%% @utility
\def\codep@autoproofof@stop{\codep@autoproofof@stop}%

% Star token used by starred \ref-like scanner branches.
\let\codep@autoproofof@star=*

% \codep@autoproofof@reset
%   Clear scanner scratch slots after one proof-heading scan.
%% @implements \codep@hookproof
\def\codep@autoproofof@reset{%
  \global\codep@autoproofof@refcount=0\relax%
  \global\let\codep@autoproofof@pendinglist\@empty%
  \global\let\codep@autoproofof@provkey\@empty%
}%

% \codep@autoproofof@rememberlabel{label}
%   Append one supported ref-family label found in a proof heading.
%% @implements \codep@hookproof
\def\codep@autoproofof@rememberlabel#1{%
  \global\advance\codep@autoproofof@refcount by 1\relax%
  \ifx\codep@autoproofof@pendinglist\@empty%
    \xdef\codep@autoproofof@pendinglist{#1}%
  \else%
    \xdef\codep@autoproofof@pendinglist{%
      \codep@autoproofof@pendinglist,#1}%
  \fi%
}%

% \codep@autoproofof@remembercsv{csv-labels}
%   Count each comma-separated label in a \cref heading reference.
%% @implements \codep@hookproof
\def\codep@autoproofof@remembercsv#1{%
  \def\codep@tmp@csvlabels{#1}%
  \@for\codep@tmp@csvlabel:=\codep@tmp@csvlabels\do{%
    \ifx\codep@tmp@csvlabel\@empty\else%
      \expandafter\codep@autoproofof@rememberlabel\expandafter{%
        \codep@tmp@csvlabel}%
    \fi%
  }%
}%

% \codep@autoproofof@scan@tokens
%   Walk heading tokens without expansion, dispatching on ref-family macros.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@tokens{%
  \futurelet\codep@autoproofof@nexttoken%
    \codep@autoproofof@scan@dispatch%
}%

% \codep@autoproofof@scan@dispatch
%   Select the scanner continuation for the next token.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@dispatch{%
  \ifx\codep@autoproofof@nexttoken\codep@autoproofof@stop%
    \let\codep@autoproofof@next\codep@autoproofof@scan@end%
  \else%
    \codep@autoproofof@selectnext%
  \fi%
  \codep@autoproofof@next%
}%

% \codep@autoproofof@selectnext
%   Choose the scanner continuation for a non-stop token.
%% @implements \codep@hookproof
\def\codep@autoproofof@selectnext{%
  \let\codep@autoproofof@next\codep@autoproofof@scan@gobble%
  \ifx\codep@autoproofof@nexttoken\@sptoken%
    \let\codep@autoproofof@next\codep@autoproofof@scan@space%
  \fi%
  \ifx\codep@autoproofof@nexttoken\ref%
    \let\codep@autoproofof@next\codep@autoproofof@scan@ref%
  \fi%
  \codep@autoproofof@selectautoref%
  \codep@autoproofof@selectcref%
}%

% \codep@autoproofof@selectautoref
%   Select \autoref only when hyperref has defined it.
%% @implements \codep@hookproof
\def\codep@autoproofof@selectautoref{%
  \ifcsundef{autoref}{}{%
    \ifx\codep@autoproofof@nexttoken\autoref%
      \let\codep@autoproofof@next\codep@autoproofof@scan@autoref%
    \fi%
  }%
}%

% \codep@autoproofof@selectcref
%   Select \cref only when cleveref has defined it.
%% @implements \codep@hookproof
\def\codep@autoproofof@selectcref{%
  \ifcsundef{cref}{}{%
    \ifx\codep@autoproofof@nexttoken\cref%
      \let\codep@autoproofof@next\codep@autoproofof@scan@cref%
    \fi%
  }%
}%

% \codep@autoproofof@scan@space
%   Consume one explicit space token and resume heading scanning.
%% @implements \codep@hookproof
\let\codep@autoproofof@savedcolon\:%
\def\:{\codep@autoproofof@scan@space}%
\expandafter\def\: {%
  \codep@autoproofof@scan@tokens%
}%
\let\:\codep@autoproofof@savedcolon%

% \codep@autoproofof@scan@end
%   Consume the scanner stop token.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@end#1{}%

% \codep@autoproofof@scan@gobble{token-or-group}
%   Consume non-ref tokens and resume heading scanning.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@gobble#1{%
  \codep@autoproofof@scan@tokens%
}%

% \codep@autoproofof@scan@ref
%   Consume \ref and then one required label argument.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@ref\ref{%
  \futurelet\codep@autoproofof@nexttoken%
    \codep@autoproofof@scan@label@dispatch%
}%

% \codep@autoproofof@scan@autoref
%   Consume \autoref and then one required label argument.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@autoref\autoref{%
  \futurelet\codep@autoproofof@nexttoken%
    \codep@autoproofof@scan@label@dispatch%
}%

% \codep@autoproofof@scan@cref
%   Consume \cref and then one comma-separated label argument.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@cref\cref{%
  \futurelet\codep@autoproofof@nexttoken%
    \codep@autoproofof@scan@csv@dispatch%
}%

% \codep@autoproofof@scan@label@dispatch
%   Route starred/non-starred \ref-like commands.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@label@dispatch{%
  \ifx\codep@autoproofof@nexttoken\codep@autoproofof@star%
    \let\codep@autoproofof@next\codep@autoproofof@scan@label@star%
  \else%
    \let\codep@autoproofof@next\codep@autoproofof@scan@label%
  \fi%
  \codep@autoproofof@next%
}%

% \codep@autoproofof@scan@label{label}
%   Record one label and resume heading scanning.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@label#1{%
  \codep@autoproofof@rememberlabel{#1}%
  \codep@autoproofof@scan@tokens%
}%

% \codep@autoproofof@scan@label@star*{label}
%   Record a starred \ref-like label and resume scanning.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@label@star*#1{%
  \codep@autoproofof@rememberlabel{#1}%
  \codep@autoproofof@scan@tokens%
}%

% \codep@autoproofof@scan@csv@dispatch
%   Route starred/non-starred \cref commands.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@csv@dispatch{%
  \ifx\codep@autoproofof@nexttoken\codep@autoproofof@star%
    \let\codep@autoproofof@next\codep@autoproofof@scan@csv@star%
  \else%
    \let\codep@autoproofof@next\codep@autoproofof@scan@csv%
  \fi%
  \codep@autoproofof@next%
}%

% \codep@autoproofof@scan@csv{csv-labels}
%   Record one or more \cref labels and resume heading scanning.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@csv#1{%
  \codep@autoproofof@remembercsv{#1}%
  \codep@autoproofof@scan@tokens%
}%

% \codep@autoproofof@scan@csv@star*{csv-labels}
%   Record starred \cref labels and resume heading scanning.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan@csv@star*#1{%
  \codep@autoproofof@remembercsv{#1}%
  \codep@autoproofof@scan@tokens%
}%

% \codep@autoproofof@allocateunresref{macro}
%   Allocate one unresolved-reference source key.
%% @implements \codep@hookproof
\def\codep@autoproofof@allocateunresref#1{%
  \global\advance\codep@autoproofof@unresrefcount by 1\relax%
  \edef#1{unresref:\the\codep@autoproofof@unresrefcount}%
}%

% \codep@autoproofof@ensureunresref{macro}
%   Allocate at most one provisional source key for this heading scan.
%% @implements \codep@hookproof
\def\codep@autoproofof@ensureunresref#1{%
  \ifx\codep@autoproofof@provkey\@empty%
    \codep@autoproofof@allocateunresref{\codep@autoproofof@provkey}%
  \fi%
  \let#1\codep@autoproofof@provkey%
}%

% \codep@autoproofof@markheadsuppress{label}
%   Suppress the ordinary ref-edge produced by proof optional-heading
%   typesetting; the proof attribution resolver writes the semantic edge.
%% @utility
\def\codep@autoproofof@markheadsuppress#1{%
  \ifcsundef{%
      codep@autoproofof@headsuppress@#1}{%
    \count@=0\relax%
  }{%
    \count@=\csuse{codep@autoproofof@headsuppress@#1}\relax%
  }%
  \advance\count@ by 1\relax%
  \csxdef{codep@autoproofof@headsuppress@#1}{%
    \the\count@}%
}%

% \codep@autoproofof@ifheadsuppressed{label}{then}{else}
%   Consume one heading-suppression ticket for label, if present.
%% @utility
\def\codep@autoproofof@ifheadsuppressed#1#2#3{%
  \ifcsundef{%
      codep@autoproofof@headsuppress@#1}{%
    #3%
  }{%
    \count@=\csuse{codep@autoproofof@headsuppress@#1}\relax%
    \ifnum\count@>0\relax%
      \advance\count@ by -1\relax%
      \csxdef{codep@autoproofof@headsuppress@#1}{%
        \the\count@}%
      #2%
    \else%
      #3%
    \fi%
  }%
}%

% \codep@autoproofof@routeforward{label}
%   Queue an unresolved heading label through the proof-ref drain rail.
%% @behavior B-PROOF-UNRESREF
\def\codep@autoproofof@routeforward#1{%
  \def\codep@tmp@autoproofofshoulddefer{1}%
  \ifcsundef{codep@lblentity@#1}{%
    \ifcsundef{codep@lblnum@#1}{%
    }{%
      \let\codep@tmp@autoproofofshoulddefer\@empty%
    }%
  }{}%
  \ifx\codep@tmp@autoproofofshoulddefer\@empty%
  \else%
    \codep@autoproofof@ensureunresref{\codep@tmp@autoproofofprov}%
    \ifcodep@proofdisplaypending%
      \codep@atomsetkey{\codep@currentproofid}{\codep@tmp@autoproofofprov}%
      \global\codep@proofdisplaypendingfalse%
      \global\codep@autoproofof@eligiblefalse%
      \global\let\codep@pendingproofbind\@empty%
      \codep@proof@adjcandidate@drop{\codep@currentproofid}%
    \fi%
    \edef\codep@tmp@autoproofofdefer{%
      \noexpand\codep@defer@proofof{\noexpand\codep@autoproofof@resolve}%
        {\codep@currentproofid}{\unexpanded{#1}}%
        {\codep@tmp@autoproofofprov}}%
    \codep@tmp@autoproofofdefer%
  \fi%
}%

% \codep@autoproofof@dispatchlabel{label}
%   Resolve same-run heading labels now; otherwise allocate and defer.
%% @implements \codep@hookproof
\def\codep@autoproofof@dispatchlabel#1{%
  \ifx\codep@currentproofid\@empty%
  \else%
    \codep@autoproofof@markheadsuppress{#1}%
    \codep@subsystem@recordtotal{proofof}%
    \ifcsundef{codep@lblentity@samerun@#1}{%
      % see @behavior B-PROOF-UNRESREF at
      % \codep@autoproofof@routeforward.
      \codep@autoproofof@routeforward{#1}%
    }{%
      \codep@autoproofof@resolve{\codep@currentproofid}{#1}{}%
    }%
  \fi%
}%

% \codep@autoproofof@scan{heading}
%   Scan a proof heading and route each supported label independently.
%% @implements \codep@hookproof
\def\codep@autoproofof@scan#1{%
  \codep@autoproofof@reset%
  \codep@autoproofof@scan@tokens#1\codep@autoproofof@stop%
  \@for\codep@tmp@autoproofoflabel:=\codep@autoproofof@pendinglist\do{%
    \ifx\codep@tmp@autoproofoflabel\@empty\else%
      \expandafter\codep@autoproofof@dispatchlabel\expandafter{%
        \codep@tmp@autoproofoflabel}%
    \fi%
  }%
  \codep@autoproofof@reset%
}%

% \codep@proofof@attribcount@get{proof-id}{macro}
%   Return the number of successful proof-attribution resolutions
%   already performed for proof-id.
%% @utility
\def\codep@proofof@attribcount@get#1#2{%
  \codep@proof@identitykey{#1}{\codep@tmp@attribproofkey}%
  \codep@prooftargetmeta@getcount{\codep@tmp@attribproofkey}{#2}%
  \ifnum#2>0\relax%
  \else%
    \ifcsundef{%
        codep@proofof@attribcount@#1}{%
      \def#2{0}%
    }{%
      \edef#2{\csuse{codep@proofof@attribcount@#1}}%
    }%
  \fi%
}%

% \codep@proofof@attribcount@advance{proof-id}
%   Mark one successful proof-attribution resolution for proof-id.
%% @implements \codep@proofof@resolve
\def\codep@proofof@attribcount@advance#1{%
  \codep@proofof@attribcount@get{#1}{\codep@tmp@proofofcount}%
  \count@=\codep@tmp@proofofcount\relax%
  \advance\count@ by 1\relax%
  \csxdef{codep@proofof@attribcount@#1}{%
    \the\count@}%
}%

% \codep@proofof@attribcount@clear{proof-id}
%   Clear per-proof attribution count when the proof scope closes.
%% @implements \codep@hookproof@end
\def\codep@proofof@attribcount@clear#1{%
  \global\expandafter\let%
    \csname codep@proofof@attribcount@#1\endcsname\relax%
}%

% \codep@proofof@capturejointmeta{proof-id}{proof-key}
%   Preserve entity metadata for a non-final proof key when a later
%   explicit proof attribution joins the proof to another target.  The
%   keymap rail is deliberately skipped for joint attribution, so each
%   proof key needs its own parent metadata for source-token rendering.
%% @behavior B-PROOF-JOINT
\def\codep@proofof@capturejointmeta#1#2{%
  \expandafter\let\expandafter\codep@tmp@jointparent%
    \csname codep@proofparent@#1\endcsname%
  \ifx\codep@tmp@jointparent\relax%
    \let\codep@tmp@jointparent\@empty%
  \fi%
  \ifx\codep@tmp@jointparent\@empty\else%
    \expandafter\codep@splitprefix#2\@nil%
    \codep@captureentitymeta{#2}{proof}{\codep@tmp@num}{proof}%
      {\codep@tmp@jointparent}%
  \fi%
}%

% \codep@autoproofof@markseen{envname}
%   Mark that the patched optional-heading body ran for this proof.
%% @implements \codep@hookproof
\def\codep@autoproofof@markseen#1{%
  \ifx\codep@currentproofid\@empty\else%
    \csgdef{codep@autoproofof@seen@\codep@currentproofid}{1}%
  \fi%
}%

% \codep@autoproofof@warnclobbered{envname}
%   Warn once when a proof redefinition removes the heading patch.
%% @implements \codep@hookproof
\def\codep@autoproofof@warnclobbered#1{%
  \ifcsundef{codep@autoproofof@warned@#1}{%
    \PackageWarning{codependent}{Automatic proof-heading detection for\space%
      '#1' was disabled by a proof environment redefinition;\space%
      use explicit \string\codepproofof\space for affected proofs}%
    \csgdef{codep@autoproofof@warned@#1}{1}%
  }{}%
}%

% \codep@autoproofof@checkseen{envname}{proof-id}
%   Verify that the patched optional-heading body survived to this proof.
%% @implements \codep@hookproof
\def\codep@autoproofof@checkseen#1#2{%
  \ifcsundef{codep@autoproofof@seen@#2}{%
    \codep@autoproofof@warnclobbered{#1}%
  }{%
    \csgundef{codep@autoproofof@seen@#2}%
  }%
}%

% \codep@autoproofof@heading{envname}{heading}
%   Entry point prepended to proof's internal optional-heading body.
%% @implements \codep@hookproof
%@effect state-only
\def\codep@autoproofof@heading#1#2{%
  \ifbool{codep@tracked}{%
    \codep@autoproofof@markseen{#1}%
    \ifcodep@autoproofof@eligible%
      \codep@autoproofof@scan{#2}%
      \codep@proof@adjacent@finalize%
      \global\codep@autoproofof@eligiblefalse%
    \fi%
    \codep@proof@captureheadinganchor{\codep@currentproofid}%
  }{}%
}%

\begingroup
  \catcode`\#=12
  % \codep@autoproofof@install@proof
  %   Patch proof's generated optional-argument body under catcode-12 #.
  %% @implements \codep@hookproof
%@effect inline-material
  \gdef\codep@autoproofof@install@proof{%
    \ifcsundef{proof}{}{%
      \codep@proof@install@heading{\csname\string\proof\endcsname}{inline-material}{%
        \codep@autoproofof@heading{proof}{#1}%
      }{%
        \PackageWarning{codependent}{Automatic proof-heading detection\space%
          unavailable: could not patch proof's optional-heading body;\space%
          use explicit \string\codepproofof\space for separated proofs}%
        \csgdef{codep@autoproofof@warned@proof}{1}%
      }%
    }%
  }%
\endgroup
\AtBeginDocument{%
  \global\codep@autoproofof@unresrefcount=0\relax%
  \codep@autoproofof@install@proof%
}

%% @implements \codep@hookproof@begin
% \codep@proofstatesave{proof-id}
%   Save the outer proof state under the nested proof-id.
\def\codep@proofstatesave#1{%
  \csxdef{codep@savedproofid@#1}{%
    \codep@currentproofid}%
  \ifcodep@proofdisplaypending%
    \csgdef{codep@savedproofpending@#1}{1}%
  \else%
    \csgdef{codep@savedproofpending@#1}{0}%
  \fi%
  \ifcodep@autoproofof@eligible%
    \csgdef{codep@savedproofautoeligible@#1}{1}%
  \else%
    \csgdef{codep@savedproofautoeligible@#1}{0}%
  \fi%
  \ifcodep@proof@adjcommit@needed%
    \csgdef{codep@savedproofadjcommit@#1}{1}%
  \else%
    \csgdef{codep@savedproofadjcommit@#1}{0}%
  \fi%
  \csxdef{codep@savedproofbind@#1}{%
    \codep@pendingproofbind}%
  \csxdef{codep@savedproofadjkey@#1}{%
    \codep@proofadj@pendinganchormapkey}%
  \csxdef{codep@savedproofadjanchor@#1}{%
    \codep@proofadj@pendinganchormapanchor}%
  \global\codep@proofneststack=\expandafter{%
    \the\codep@proofneststack{\codep@currentproofid}}%
}%

%% @implements \codep@hookproof@end
% \codep@proofstaterestore{proof-id}
%   Restore any outer proof state saved under proof-id.
\def\codep@proofstaterestore#1{%
  \ifcsundef{codep@savedproofid@#1}{%
    \global\let\codep@currentproofid\@empty%
    \codep@pendingproofbind@checkoverwrite%
    \global\let\codep@pendingproofbind\@empty%
    \global\codep@proofdisplaypendingfalse%
    \global\codep@autoproofof@eligiblefalse%
    \global\codep@proof@adjcommit@neededfalse%
    \global\let\codep@proofadj@pendinganchormapkey\@empty%
    \global\let\codep@proofadj@pendinganchormapanchor\@empty%
  }{%
    \global\letcs\codep@currentproofid{codep@savedproofid@#1}%
    \edef\codep@tmp@proofpending{%
      \csuse{codep@savedproofpending@#1}}%
    \def\codep@tmp@proofone{1}%
    \ifx\codep@tmp@proofpending\codep@tmp@proofone%
      \global\codep@proofdisplaypendingtrue%
    \else%
      \global\codep@proofdisplaypendingfalse%
    \fi%
    \edef\codep@tmp@proofautoeligible{%
      \csuse{codep@savedproofautoeligible@#1}}%
    \ifx\codep@tmp@proofautoeligible\codep@tmp@proofone%
      \global\codep@autoproofof@eligibletrue%
    \else%
      \global\codep@autoproofof@eligiblefalse%
    \fi%
    \edef\codep@tmp@proofadjcommit{%
      \csuse{codep@savedproofadjcommit@#1}}%
    \ifx\codep@tmp@proofadjcommit\codep@tmp@proofone%
      \global\codep@proof@adjcommit@neededtrue%
    \else%
      \global\codep@proof@adjcommit@neededfalse%
    \fi%
    \global\letcs\codep@pendingproofbind{codep@savedproofbind@#1}%
    \global\letcs\codep@proofadj@pendinganchormapkey{codep@savedproofadjkey@#1}%
    \global\letcs\codep@proofadj@pendinganchormapanchor{codep@savedproofadjanchor@#1}%
    \csgundef{codep@savedproofid@#1}%
    \csgundef{codep@savedproofpending@#1}%
    \csgundef{codep@savedproofautoeligible@#1}%
    \csgundef{codep@savedproofadjcommit@#1}%
    \csgundef{codep@savedproofbind@#1}%
    \csgundef{codep@savedproofadjkey@#1}%
    \csgundef{codep@savedproofadjanchor@#1}%
  }%
}%

%% @behavior B-PROOF-OFF
%% @behavior B-PROOF-INNER
%% @behavior B-PROOF-ADJ
%% @behavior B-PROOF-NONADJ
% \codep@hookproof@begin
%   Begin dispatch for proof environments.
%@effect state-only
\newcommand*{\codep@hookproof@begin}{%
  \codep@closeparagraphifopen%
  \global\codep@autoproofof@eligiblefalse%
  \ifbool{codep@proofsnumbered}{%
    \codep@ctxpeekkind\codep@tmp@ctxkind%
    \def\codep@tmp@proofkind{proof}%
    \ifx\codep@currentproofid\@empty%
      \ifnum\codep@ctxdepth>0\relax%
        \global\codep@autoproofof@eligiblefalse%
        \global\advance\codep@suppressdepth by 1\relax%
      \else\ifnum\codep@suppressdepth>0\relax%
        \global\codep@autoproofof@eligiblefalse%
        \global\advance\codep@suppressdepth by 1\relax%
      \else%
        \codep@allocatomid{\codep@thisproofid}{proof}%
        \xdef\codep@currentproofid{\codep@thisproofid}%
        \codep@proof@setidentity{\codep@currentproofid}%
        \codep@proof@capturebeginpage{\codep@currentproofid}%
        \codep@ctxpush{\codep@currentproofid}{proof}%
        \global\advance\codep@suppressdepth by 1\relax%
        \global\let\codep@proofadj@pendinganchormapkey\@empty%
        \global\let\codep@proofadj@pendinganchormapanchor\@empty%
        \codep@pendingproofbind@checkoverwrite%
        \let\codep@pendingproofbind\@empty%
        \codep@proof@standalone%
        \ifx\codep@pendingresultid\@empty%
        \else%
          \codep@proof@adjacent%
        \fi%
      \fi\fi%
    \else%
      \codep@allocatomid{\codep@thisproofid}{proof}%
      \codep@proofstatesave{\codep@thisproofid}%
      \xdef\codep@currentproofid{\codep@thisproofid}%
      \codep@proof@setidentity{\codep@currentproofid}%
      \codep@proof@capturebeginpage{\codep@currentproofid}%
      \codep@ctxpush{\codep@currentproofid}{proof}%
      \global\advance\codep@suppressdepth by 1\relax%
      \global\let\codep@proofadj@pendinganchormapkey\@empty%
      \global\let\codep@proofadj@pendinganchormapanchor\@empty%
      \codep@pendingproofbind@checkoverwrite%
      \let\codep@pendingproofbind\@empty%
      \codep@proof@standalone%
    \fi%
  }{%
    \global\codep@autoproofof@eligiblefalse%
    \global\advance\codep@suppressdepth by 1\relax%
  }%
}%

%% @behavior B-PROOF-NONADJ
% \codep@proof@standalone
%   Leave the current proof unresolved until fallback or \codepproofof.
\newcommand*{\codep@proof@standalone}{%
  \global\codep@proofdisplaypendingtrue%
  \global\codep@autoproofof@eligibletrue%
  \global\codep@proof@adjcommit@neededfalse%
}%

%% @utility
% Callers MUST ensure #1 is non-empty before calling.
% Helper does NOT validate; lint forbids raw destination primitives
% outside this body. Possibly-empty callers wrap in \ifx\<name>\@empty
% guard. Structurally-non-empty callers (e.g. Track-2 align where
% anchor name has literal prefix codep.eq.) document the structural
% argument and omit the guard.
%@effect zero-visible-destination
\def\codep@emit@destination#1{%
  \Hy@raisedlink{\hyper@anchorstart{#1}\hyper@anchorend}%
}%

%% @utility
% \codep@proof@beginanchorname{proof-id}{macro}
%   Compute the emitted proof-begin anchor name for proof-id.
%   Adjacent proofs use their resolved proof:N.M key; standalone
%   and not-yet-rebound proofs fall back to the opaque atom id.
\newcommand*{\codep@proof@beginanchorname}[2]{%
  \codep@atomgetkey{#1}{\codep@tmp@proofkey}%
  \ifx\codep@tmp@proofkey\@empty%
    \edef#2{codep-proof:#1}%
  \else%
    \expandafter\codep@splitprefix\codep@tmp@proofkey\@nil%
    \edef#2{codep-proof:\codep@tmp@num}%
  \fi%
}%

%% @behavior B-LINK-PROOF-DEST
%% @behavior B-PROOF-ANCHOR-NEAR-HEADING
% \codep@proof@capturebeginanchor{proof-id}
%   Emit a zero-size proof-begin destination and remember its
%   anchor name for later proof-key binding.
%@effect zero-visible-destination
\newcommand*{\codep@proof@capturebeginanchor}[1]{%
  \@ifpackageloaded{hyperref}{%
    \codep@proof@beginanchorname{#1}{\codep@tmp@proofbeginanchor}%
    \codep@emit@destination{\codep@tmp@proofbeginanchor}%
    \csxdef{codep@proofbeginanchor@#1}{%
      \codep@tmp@proofbeginanchor}%
  }{}%
}%

%% @implements \codep@proof@capturebeginanchor
% \codep@proof@captureheadinganchor{proof-id}
%   Stage the proof destination after the proof optional argument is
%   parsed.  para/begin emits at the heading-adjacent body paragraph;
%   proof end remains an idempotent fallback for empty proofs.
%@effect state-only
\newcommand*{\codep@proof@captureheadinganchor}[1]{%
  \edef\codep@tmp@headingproofid{#1}%
  \ifx\codep@tmp@headingproofid\@empty\else%
    \ifcsundef{%
        codep@proofbeginanchor@\codep@tmp@headingproofid%
    }{%
      \@ifpackageloaded{hyperref}{%
        \codep@proof@beginanchorname{\codep@tmp@headingproofid}{%
          \codep@tmp@proofbeginanchor}%
        \ifx\codep@tmp@proofbeginanchor\@empty\else%
          \csxdef{codep@proofbeginanchor@\codep@tmp@headingproofid}{%
                \codep@tmp@proofbeginanchor}%
          \csxdef{codep@proofpendingheadinganchor@\codep@tmp@headingproofid}{%
                \codep@tmp@proofbeginanchor}%
        \fi%
      }{}%
    }{}%
  \fi%
}%

%% @behavior B-LINK-PROOF-DEST
%% @behavior B-PROOF-ANCHOR-NEAR-HEADING
% \codep@proof@emitpendingheadinganchor
%   Emit the current proof heading destination once.
%@effect zero-visible-destination
\def\codep@proof@emitpendingheadinganchor{%
  \edef\codep@tmp@pendingproofid{\codep@currentproofid}%
  \ifx\codep@tmp@pendingproofid\@empty\else%
    \ifcsundef{codep@proofpendingheadinganchor@%
        \codep@tmp@pendingproofid}{%
    }{%
      \edef\codep@tmp@pendingproofanchor{%
        \csuse{codep@proofpendingheadinganchor@%
          \codep@tmp@pendingproofid}}%
      \ifx\codep@tmp@pendingproofanchor\@empty\else%
        \@ifpackageloaded{hyperref}{%
          \codep@emit@destination{\codep@tmp@pendingproofanchor}%
        }{}%
      \fi%
      \global\expandafter\let\csname codep@proofpendingheadinganchor@%
        \codep@tmp@pendingproofid\endcsname\relax%
    }%
  \fi%
}%

%% @behavior B-LINK-ADJ-PROOF
% \codep@proof@bindbeginanchor{proof-id}{proof-key}
%   Bind proof-key to the proof-begin destination emitted for proof-id.
%@effect immediate-write
\newcommand*{\codep@proof@bindbeginanchor}[2]{%
  \ifcsundef{codep@proofbeginanchor@#1}{%
    \codep@proof@beginanchorname{#1}{\codep@tmp@proofanchor}%
  }{%
    \edef\codep@tmp@proofanchor{%
      \csuse{codep@proofbeginanchor@#1}}%
  }%
  \codep@writeanchormapvalue{#2}{\codep@tmp@proofanchor}%
}%

%% @utility
% \codep@proof@capturebeginpage{proof-id}
%   Snapshot \thepage at proof begin so later key rebinds can
%   keep the proof-start page rather than the resolution page.
\newcommand*{\codep@proof@capturebeginpage}[1]{%
  \edef\codep@tmp@proofbeginpage{\thepage}%
  \csxdef{codep@proofbeginpage@#1}{%
    \codep@tmp@proofbeginpage}%
}%

%% @utility
% \codep@proof@writebeginpage{proof-id}{proof-key}
%   Persist the proof-start page under the current proof key.
%@effect immediate-write
\newcommand*{\codep@proof@writebeginpage}[2]{%
  \ifcsundef{codep@proofbeginpage@#1}{%
    \codep@writeanchorpagecurrent{#2}%
  }{%
    \edef\codep@tmp@proofpage{%
      \csuse{codep@proofbeginpage@#1}}%
    \codep@writeanchorpage{#2}{\codep@tmp@proofpage}%
  }%
}%

%% @behavior B-PROOF-NONADJ
%% @behavior B-EDGE-EMPTY-PROOF
% \codep@proof@materialize
%   Materialize the current proof as a standalone proof atom.
%   Standalone proofs do NOT consume a shared-counter slot — their
%   key uses the opaque atom-id (\codep@currentproofid → "proof:a<N>")
%   so the atom remains addressable for graph queries while being
%   suppressed from rendered source-token output by the
%   collapsebr classifier (codependent-render.sty:codep@collapsebr@cb).
%   Adjacent and \codepproofof-rebound proofs continue to bind a
%   "proof:N.M" key via \codep@proof@adjacent / \codep@proofof@resolve;
%   only the standalone path lands here.
%@effect immediate-write
\newcommand*{\codep@proof@materialize}{%
  \global\codep@proofdisplaypendingfalse%
  \global\codep@autoproofof@eligiblefalse%
  \edef\codep@tmp@proofkey{proof:\codep@currentproofid}%
  \codep@atomsetkey{\codep@currentproofid}{\codep@tmp@proofkey}%
  \codep@proof@writebeginpage{\codep@currentproofid}{\codep@tmp@proofkey}%
  \codep@proof@bindbeginanchor{\codep@currentproofid}{\codep@tmp@proofkey}%
  \codep@cdpwrite@atom{%
    \string\codep@cdp@atom{\codep@currentproofid}{proof}}%
  \codep@cdpwrite@atom{%
    \string\codep@cdp@meta{\codep@currentproofid}{src}%
      {\jobname.tex:\the\inputlineno:1}}%
  \codep@registeratom{\codep@tmp@proofkey}{proof}%
  \codep@render@refresh{\codep@tmp@proofkey}%
  \ifbool{codep@proofwarnings}{%
    \PackageWarning{codependent}{Proof not adjacent to a tracked\space%
      environment and has no \string\codepproofof\space binding;\space%
      suppressed from backref source-token output}%
  }{}%
}%

%% @behavior B-PROOF-ADJ
%% @behavior B-PROOF-DELAYED-COMMIT
% \codep@proof@adjacent
%   Stage the pending adjacent theorem/result atom for delayed binding.
%@effect immediate-write
\newcommand*{\codep@proof@adjacent}{%
  \codep@atomgetkey{\codep@pendingresultid}{\codep@tmp@adjtargetkey}%
  \codep@atomgetdisplay{\codep@pendingresultid}{\codep@tmp@adjtargetdisplay}%
  % see @behavior B-PROOF-DELAYED-COMMIT on this macro.
  \csxdef{codep@adjcandidate@\codep@currentproofid}{\codep@pendingresultid}%
  \csxdef{codep@adjcandidate@target@\codep@currentproofid}{\codep@tmp@adjtargetkey}%
  \csxdef{codep@adjcandidate@display@\codep@currentproofid}{\codep@tmp@adjtargetdisplay}%
  \csxdef{codep@proofadjtarget@\codep@currentproofid}{\codep@tmp@adjtargetkey}%
  \csxdef{codep@proofadjdisplay@\codep@currentproofid}{\codep@tmp@adjtargetdisplay}%
  \global\codep@proof@adjcommit@neededtrue%
  \codep@atomgetkey{\codep@currentproofid}{\codep@tmp@proofkey}%
  \global\let\codep@proofadj@pendinganchormapkey\@empty%
  \global\let\codep@proofadj@pendinganchormapanchor\@empty%
  \codep@proof@bindbeginanchor{\codep@currentproofid}{\codep@tmp@proofkey}%
  \codep@proof@writebeginpage{\codep@currentproofid}{\codep@tmp@proofkey}%
  \global\let\codep@pendingresultid\@empty%
}%

% \codep@proof@adjcandidate@clear{proof-id}
%   Clear staged adjacent-candidate state for proof-id.
%% @implements \codep@proof@adjacent
% see @behavior B-PROOF-DELAYED-COMMIT at \codep@proof@adjacent.
\def\codep@proof@adjcandidate@clear#1{%
  \global\expandafter\let\csname codep@adjcandidate@#1\endcsname\relax%
  \global\expandafter\let%
    \csname codep@adjcandidate@target@#1\endcsname\relax%
  \global\expandafter\let%
    \csname codep@adjcandidate@display@#1\endcsname\relax%
}%

% \codep@proof@adjcandidate@drop{proof-id}
%   Drop a staged adjacent candidate without committing it.
%% @implements \codep@proof@adjacent
\def\codep@proof@adjcandidate@drop#1{%
  \global\codep@proof@adjcommit@neededfalse%
  \codep@proof@adjcandidate@clear{#1}%
  \global\expandafter\let\csname codep@proofadjtarget@#1\endcsname\relax%
  \global\expandafter\let\csname codep@proofadjdisplay@#1\endcsname\relax%
}%

% \codep@proof@adjacent@commit{proof-id}{target-id}
%   Commit a staged adjacent binding after proof-heading scan returns.
%% @implements \codep@proof@adjacent
% see @behavior B-PROOF-DELAYED-COMMIT at \codep@proof@adjacent.
\def\codep@proof@adjacent@commit#1#2{%
  \codep@bindproofparent{#1}{#2}{statement}%
  \global\codep@proofdisplaypendingfalse%
  \codep@atomgetkey{#1}{\codep@tmp@proofkey}%
  \codep@render@refresh{\codep@tmp@proofkey}%
  \global\codep@proof@adjcommit@neededfalse%
  \codep@proof@adjcandidate@clear{#1}%
}%

% \codep@proof@adjacent@finalize
%   Commit the current proof's staged adjacent candidate, if any.
%% @implements \codep@proof@adjacent
% see @behavior B-PROOF-DELAYED-COMMIT at \codep@proof@adjacent.
\def\codep@proof@adjacent@finalize{%
  \ifcodep@proof@adjcommit@needed%
    \ifcsundef{%
        codep@adjcandidate@\codep@currentproofid}{%
      \global\codep@proof@adjcommit@neededfalse%
    }{%
      \edef\codep@tmp@adjproofid{\codep@currentproofid}%
      \edef\codep@tmp@adjtargetid{%
        \csuse{codep@adjcandidate@\codep@tmp@adjproofid}}%
      \codep@proof@adjacent@commit{%
        \codep@tmp@adjproofid}{\codep@tmp@adjtargetid}%
    }%
  \fi%
}%

%% @behavior B-PROOF-OFF
%% @behavior B-PROOF-NONADJ
% \codep@hookproof@end
%   Finalize and unwind the current proof environment.  Stash the
%   current proof key in \codep@proofend@pendingclear BEFORE
%   \codep@proofstaterestore overwrites \codep@currentproofid, so
%   \codep@hookproof@afterend can later clear the per-atom
%   \codep@manuallyemitted@<key> flag after the environment closes.
%@effect immediate-write
\newcommand*{\codep@hookproof@end}{%
  \ifbool{codep@proofsnumbered}{%
    \codep@ctxpeekkind\codep@tmp@ctxkind%
    \def\codep@tmp@proofkind{proof}%
    \ifx\codep@tmp@ctxkind\codep@tmp@proofkind%
      \codep@proof@emitpendingheadinganchor%
      \ifcodep@proofdisplaypending%
        \codep@proof@materialize%
      \fi%
      \codep@ctxpeekid\codep@thisproofid%
      \codep@autoproofof@checkseen{proof}{\codep@thisproofid}%
      \codep@render@proof@end%
      \codep@ctxpop{proof}%
      \global\let\codep@pendingresultid\@empty%
      \codep@atomgetkey{\codep@currentproofid}{\codep@tmp@proofkey}%
      \xdef\codep@proofend@pendingclear{\codep@tmp@proofkey}%
      % W03-P03/W05-A2: capture entitymeta for this just-closed proof.
      % The stable proof source key is proof:a<N>; display now comes
      % from proof target metadata rather than the key suffix.
      \codep@graph@getdisplay{\codep@tmp@proofkey}{\codep@tmp@num}%
      \ifx\codep@tmp@num\@empty%
        \expandafter\codep@splitprefix\codep@tmp@proofkey\@nil%
      \fi%
      \codep@prooftargetmeta@firstkey{\codep@tmp@proofkey}{%
        \codep@tmp@proofparentval}%
      \ifx\codep@tmp@proofparentval\@empty%
        \expandafter\let\expandafter\codep@tmp@proofparentval%
          \csname codep@proofparent@\codep@thisproofid\endcsname%
      \fi%
      \ifx\codep@tmp@proofparentval\relax%
        \let\codep@tmp@proofparentval\@empty%
      \fi%
      \codep@captureentitymeta{\codep@tmp@proofkey}{proof}%
        {\codep@tmp@num}{proof}{\codep@tmp@proofparentval}%
      \codep@proofof@attribcount@clear{\codep@thisproofid}%
      \codep@proofstaterestore{\codep@thisproofid}%
    \fi%
  }{}%
  \global\advance\codep@suppressdepth by -1\relax%
}%

%% @behavior B-REND-INLINE
% \codep@hookproof@afterend
%   Post-env hook body.  Proof destinations are emitted at
%   proof-begin; this afterend hook only runs the rendering
%   follow-up and clears the per-atom \codep@manuallyemitted@<key>
%   flag for the proof that just closed.
%@effect inline-material
\newcommand*{\codep@hookproof@afterend}{%
  \codep@render@proof@afterend%
  \ifnum\codep@replaydepth=0\relax%
    \ifx\codep@proofend@pendingclear\@empty\else%
      \codep@manuallyemitted@clear@key{\codep@proofend@pendingclear}%
      \global\let\codep@proofend@pendingclear\@empty%
    \fi%
  \fi%
}%

%% ===================================================================
%% Section 7: Paragraph numbering
%% ===================================================================

%% @behavior B-SUPP-EXTEND
% \codep@suppressenv{envname}
%   Increment suppressdepth on entry, decrement it on exit.
%@effect state-only
\newcommand*{\codep@suppressenv}[1]{%
  \AtBeginEnvironment{#1}{%
    \global\advance\codep@suppressdepth by 1\relax
  }%
  \AtEndEnvironment{#1}{%
    \global\advance\codep@suppressdepth by -1\relax
  }%
}%

%% --- Equation backref tracking (two-track design) ---
%% Track 1: single-number environments (equation).
%% Track 2: multi-number environments (align, gather, multline, flalign).

%% @behavior B-EQ-OUTER
%% @behavior B-EQ-ALL
%% @behavior B-EQ-OFF
%% @behavior B-EDGE-PARAOFF-EQ
% \codep@eqshouldtrack
%   Set \codep@eqatom to a non-empty sentinel if this block owns refs.
\newcommand*{\codep@eqshouldtrack}{%
  \def\codep@eqatom{}%
  \ifx\codep@equationmode\codep@const@off%
  \else\ifx\codep@equationmode\codep@const@outer%
    \ifnum\codep@trackeddepth>0\relax\else%
      \def\codep@eqatom{pending}%
    \fi%
  \else%
    \def\codep@eqatom{pending}%
  \fi\fi%
}%

%% @behavior B-EQ-TRACK1
% \codep@trackeqenv{envname}
%   Track one-row equation environments.
%@effect state-only
\newcommand*{\codep@trackeqenv}[1]{%
  \codep@hook@install{post-begin}{#1}{state-only}{%
    \global\let\codep@pendingresultid\@empty%
    \global\advance\codep@suppressdepth by 1\relax%
    \booltrue{codep@inequation}%
    \boolfalse{codep@eqmultiline}%
    \boolfalse{codep@eqnumbered}%
    \codep@getcurrentownerid\codep@tmp@eqowner%
    \xdef\codep@eqfallbacksourceid{\codep@tmp@eqowner}%
    \global\let\codep@currenteqsourceid\@empty%
    \ifnum\codep@trackeddepth>0\relax\else%
      \global\def\codep@eq@lbltype@pending{equation}%
    \fi%
    \codep@eqshouldtrack%
    \ifx\codep@eqatom\@empty\else%
      \codep@allocatomid{\codep@currenteqsourceid}{equation}%
      \codep@ctxpush{\codep@currenteqsourceid}{equation}%
    \fi%
  }%
  \codep@hook@install{pre-end}{#1}{state-only}{%
    \boolfalse{codep@inequation}%
    \def\codep@eqatom{}%
    \ifx\codep@currenteqsourceid\@empty\else%
      \codep@ctxpop{equation}%
    \fi%
    \global\let\codep@currenteqsourceid\@empty%
    \global\let\codep@eqfallbacksourceid\@empty%
    \global\advance\codep@suppressdepth by -1\relax%
  }%
  \codep@hook@install{after-env}{#1}{state-only}{%
    \global\let\codep@eq@lbltype@pending\@empty%
  }%
}%

%% @behavior B-EQ-TRACK2
% \codep@trackalignenv{envname}
%   Track multi-row equation environments.
%@effect state-only
\newcommand*{\codep@trackalignenv}[1]{%
  \codep@hook@install{post-begin}{#1}{state-only}{%
    \global\let\codep@pendingresultid\@empty%
    \global\advance\codep@suppressdepth by 1\relax%
    \booltrue{codep@inequation}%
    \booltrue{codep@eqmultiline}%
    \boolfalse{codep@eqnumbered}%
    \codep@getcurrentownerid\codep@tmp@eqowner%
    \xdef\codep@eqfallbacksourceid{\codep@tmp@eqowner}%
    \global\let\codep@currenteqsourceid\@empty%
    \ifnum\codep@trackeddepth>0\relax\else%
      \global\def\codep@eq@lbltype@pending{equation}%
    \fi%
    \global\codep@eq@startcount=\c@equation\relax%
    % Clear SW5c pending-append guards from the previous equation block.
    \the\codep@eqpendguards%
    \global\codep@eqpendguards={}%
    \global\codep@eqpending={}%
    \global\codep@eqpendingcount=0\relax%
    \codep@eqshouldtrack%
    \ifx\codep@eqatom\@empty\else%
      \codep@allocatomid{\codep@currenteqsourceid}{equation}%
      \codep@ctxpush{\codep@currenteqsourceid}{equation}%
    \fi%
    \@ifpackageloaded{hyperref}{%
      \xdef\codep@eq@anchor{codep.eq.\the\c@equation}%
      % Structurally non-empty: literal codep.eq. prefix plus equation value.
      \codep@emit@destination{\codep@eq@anchor}%
    }{}%
  }%
  \codep@hook@install{pre-end}{#1}{state-only}{%
    \boolfalse{codep@inequation}%
    \boolfalse{codep@eqmultiline}%
    \def\codep@eqatom{}%
  }%
  \codep@hook@install{after-env}{#1}{track2-shipout-order-write}{\codep@flusheqrange}%
  \codep@hook@install{after-env}{#1}{state-only}{%
    \ifx\codep@currenteqsourceid\@empty\else%
      \codep@ctxpop{equation}%
    \fi%
    \global\let\codep@currenteqsourceid\@empty%
    \global\let\codep@eqfallbacksourceid\@empty%
    \global\let\codep@eq@lbltype@pending\@empty%
    \global\advance\codep@suppressdepth by -1\relax%
  }%
}%

%% @behavior B-EDGE-DEDUP
%% @behavior B-EDGE-MULTI-SAME
% \codep@dedupwrite{src}{tgt}
%   Per-(source, target) dedup write.  If the csname flag
%   codep@arw@<src>@<tgt> is undefined (\relax), set it to
%   \@empty and write \codep@atomref{src}{tgt} to the .aux
%   file.  Otherwise skip (already written this run).
%@effect immediate-write
\def\codep@dedupwrite#1#2{%
  \ifcsundef{%
      codep@arw@#1@#2}{%
    \global\cslet{codep@arw@#1@#2}\@empty%
    \codep@ifunresrefkey{#1}{%
      \codep@unresref@rememberref{#1}{#2}%
    }{%
      \protected@write\@auxout{}{%
        \string\codep@atomref{#1}{#2}}%
    }%
  }{}%
}

% \codep@unresref@rememberref{unresref-key}{target-label}
%   Remember atomrefs written under a provisional proof source so drain
%   can mirror them under the final proof:N.M key in the same aux pass.
%% @utility
\def\codep@unresref@rememberref#1#2{%
  \ifcsundef{codep@unresrefs@#1}{%
    \csgdef{codep@unresrefs@#1}{}%
  }{}%
  \expandafter\g@addto@macro\csname codep@unresrefs@#1\endcsname{%
    \do{#2}}%
}%

% \codep@unresref@flushrefs{unresref-key}{final-proof-key}
%   Live migration path for forward-ref proof-heading body cites.  During
%   proof body scanning, \codep@dedupwrite intercepts unresref:<N> source
%   writes and stores their targets in memory through
%   \codep@unresref@rememberref instead of emitting provisional atomrefs to
%   the .aux.  When the deferred auto resolver later learns the final
%   proof:N.M key, this helper mirrors those remembered refs under that
%   final key in the same aux pass.  The appendbr unresref branch remains as
%   a defensive backup for any provisional source that reaches replay.
%% @implements \codep@proofof@resolve
\def\codep@unresref@flushrefs#1#2{%
  \ifcsundef{codep@unresrefs@#1}{%
  }{%
    \begingroup%
      \def\codep@tmp@unresreffinal{#2}%
      \def\do##1{%
        \codep@dedupwrite{\codep@tmp@unresreffinal}{##1}}%
      \csuse{codep@unresrefs@#1}%
    \endgroup%
  }%
}%

% \codep@flusheqrange@numbered
%   Numbered-line path: counter advanced, so compute the
%   equation range, write the anchormap entry, and flush
%   all pending refs with dedup.
%% @behavior B-DISP-EQRANGE
%% @behavior B-EQ-SUBEQ
% \codep@flusheqrange@numbered
%   Compute the legacy equation range key and flush pending refs.
\def\codep@flusheqrange@numbered{%
  % Compute formatted start: saved+1 in a group.
  \begingroup
    \c@equation=\codep@eq@startcount\relax
    \advance\c@equation by 1\relax
    \xdef\codep@tmp@eqstart{\theequation}%
  \endgroup
  \edef\codep@tmp@eqend{\theequation}%
  % Build the equation:-prefixed key; display renders as (N) or (N--M).
  \ifx\codep@tmp@eqstart\codep@tmp@eqend%
    % Single numbered line: equation:N
    \edef\codep@eqatom{equation:\codep@tmp@eqstart}%
  \else%
    % Range: equation:N--M
    \edef\codep@eqatom{equation:\codep@tmp@eqstart--\codep@tmp@eqend}%
  \fi%
  \ifx\codep@currenteqsourceid\@empty\else%
    \codep@atomsetkey{\codep@currenteqsourceid}{\codep@eqatom}%
  \fi%
  % Write anchormap entry using dedicated block anchor.
  \@ifpackageloaded{hyperref}{%
    \csxdef{codep@anchor@\codep@eqatom}%
      {\codep@eq@anchor}%
    \if@filesw%
      \protected@write\@auxout{}{%
        \string\codep@anchormap{\codep@eqatom}{\codep@eq@anchor}}%
    \fi%
  }{}%
  % Flush all pending refs (with dedup).
  \if@filesw%
    \def\codep@eqpending@entry##1{%
      \codep@dedupwrite{\codep@eqatom}{##1}%
    }%
    \the\codep@eqpending%
  \fi%
}%

%% @behavior B-EQ-NOTAG
%% @behavior B-EDGE-NOTAG
% \codep@flusheqrange@fallback
%   All-notag path: replay pending refs from the enclosing owner.
\def\codep@flusheqrange@fallback{%
  \codep@atomgetkey{\codep@eqfallbacksourceid}{\codep@tmp@srcatom}%
  \ifx\codep@tmp@srcatom\@empty\else%
    \if@filesw%
      \def\codep@eqpending@entry##1{%
        \codep@dedupwrite{\codep@tmp@srcatom}{##1}%
      }%
      \the\codep@eqpending%
    \fi%
  \fi%
}%

%% @behavior B-EQ-TRACK2
%% @behavior B-USEDIN-READING-ORDER
% \codep@flusheqrange
%   Compute the equation range and flush all pending refs.
%   Called at \end{align} (Track 2).  Dispatches to
%   \codep@flusheqrange@numbered or @fallback.
%@effect track2-shipout-order-write
\def\codep@flusheqrange{%
  \ifnum\codep@eqpendingcount>0\relax%
    % Check equation mode.
    \codep@eqshouldtrack%
    \ifx\codep@eqatom\@empty%
      % Mode says don't track; silently drop pending refs.
      \global\codep@eqpending={}%
      \global\codep@eqpendingcount=0\relax
    \else
      % Check if counter advanced (at least one numbered line).
      \ifnum\c@equation>\codep@eq@startcount\relax
        \codep@flusheqrange@numbered%
      \else
        \codep@flusheqrange@fallback%
      \fi
      \global\codep@eqpending={}%
      \global\codep@eqpendingcount=0\relax
    \fi
  \fi%
}

% \codep@suppresscmd{command}
%   Patch a command to suppress numbering in its body.
%% @behavior B-SUPP-EXTEND
% \codep@suppresscmd{command}
%   Patch a command to suppress paragraph numbering in its body.
%@effect state-only
\newcommand*{\codep@suppresscmd}[1]{%
  \codep@target@install{pretocmd}{#1}{state-only}{%
    \global\advance\codep@suppressdepth by 1\relax}%
  \codep@target@install{apptocmd}{#1}{state-only}{%
    \global\advance\codep@suppressdepth by -1\relax}%
}%

%% @utility
% \codep@withsuppression{tokens}
%   Execute tokens with codep@suppressdepth incremented, then
%   decremented.  Suppression is balanced by construction.
%   \global\advance is required: caller may be inside a group
%   (e.g., \AfterEndEnvironment callbacks).
\def\codep@withsuppression#1{%
  \global\advance\codep@suppressdepth\@ne\relax%
  #1%
  \global\advance\codep@suppressdepth\m@ne\relax%
}%

\newif\ifcodep@footnotesuppressed
%% @behavior B-EDGE-FOOTNOTE
% \codep@suppressfootnote
%   Suppress paragraph atoms and source attribution while the footnote
%   body is typeset; direct wrapping avoids \footnote's \unskip path.
%@effect state-only
\newcommand*{\codep@suppressfootnote}{%
  \ifcodep@footnotesuppressed%
  \else%
    \global\codep@footnotesuppressedtrue%
    \codep@target@install{command-wrap}{\footnote}{state-only}{%
      \RenewDocumentCommand{\footnote}{o +m}{%
        \global\advance\codep@sourceblockdepth\@ne\relax%
        \codep@withsuppression{%
          \IfNoValueTF{##1}{%
            \codep@orig@footnote{##2}%
          }{%
            \codep@orig@footnote[##1]{##2}%
          }%
        }%
        \global\advance\codep@sourceblockdepth\m@ne\relax%
      }%
    }%
  \fi%
}%

% \codep@installsuppress
%   Hook suppression for standard environments.
%% @behavior B-SUPP-BOXES
%% @behavior B-SUPP-TRACKED
%% @behavior B-SUPP-WRAPPERS
%% @behavior B-SUPP-FLOATS
%% @behavior B-SUPP-QUOTE
%% @behavior B-SUPP-TABLES
%% @behavior B-SUPP-MATH
%% @behavior B-EQ-UNNUM
%@effect state-only
\newcommand*{\codep@installsuppress}{%
  \codep@suppressenv{enumerate}%
  \codep@suppressenv{itemize}%
  \codep@suppressenv{description}%
  \codep@suppressenv{quote}%
  \codep@suppressenv{quotation}%
  \codep@suppressenv{figure}%
  \codep@suppressenv{table}%
  \codep@suppressenv{minipage}%
  \codep@suppressenv{tabular}%
  \codep@suppressenv{tabularx}%
  \codep@suppressenv{longtable}%
  \codep@suppressenv{trivlist}%
  % Kernel wrappers around \trivlist (latex.ltx:15407-15460).
  % Their bodies typeset with \codep@suppressdepth==0 unless we
  % register the surface env names; \codep@suppressenv{trivlist}
  % alone does not catch para/begin inside these wrappers.
  \codep@suppressenv{center}%
  \codep@suppressenv{flushleft}%
  \codep@suppressenv{flushright}%
  \codep@suppressenv{verbatim}%
  % Numbered equation environments.
  % Track 1: single-number (counter steps at \begin).
  \codep@trackeqenv{equation}%
  % Track 2: multi-number (counter steps at \\).
  \codep@trackalignenv{align}%
  \codep@trackalignenv{gather}%
  \codep@trackalignenv{multline}%
  \codep@trackalignenv{flalign}%
  % Unnumbered/display-only: suppress paragraphs only.
  \codep@suppressenv{equation*}%
  \codep@suppressenv{displaymath}%
  \codep@suppressenv{align*}%
  \codep@suppressenv{gather*}%
  \codep@suppressenv{multline*}%
  \codep@suppressenv{flalign*}%
}

% \codep@suppresssectioning
%   Suppress atom numbering for sectioning heading paragraphs.
%   Uses LaTeX 2021+ generic cmd/<level>/before hooks, which
%   fire universally across standard classes, KOMA-Script,
%   memoir, and titlesec (unlike the old \@startsection wrapper
%   which was a no-op under those packages).
%% @behavior B-SUPP-SECTION
% \codep@suppresssectioning
%   One-shot suppression for heading paragraphs.
%@effect state-only
\newcommand*{\codep@suppresssectioning}{%
  \codep@target@install{AddToHook}{cmd/section/before}{state-only}{%
    \codep@closeparagraphifopen%
    \global\let\codep@pendingresultid\@empty%
    \global\booltrue{codep@sectioning}}%
  \codep@target@install{AddToHook}{cmd/subsection/before}{state-only}{%
    \codep@closeparagraphifopen%
    \global\let\codep@pendingresultid\@empty%
    \global\booltrue{codep@sectioning}}%
  \codep@target@install{AddToHook}{cmd/subsubsection/before}{state-only}{%
    \codep@closeparagraphifopen%
    \global\let\codep@pendingresultid\@empty%
    \global\booltrue{codep@sectioning}}%
  \codep@target@install{AddToHook}{cmd/chapter/before}{state-only}{%
    \codep@closeparagraphifopen%
    \global\let\codep@pendingresultid\@empty%
    \global\booltrue{codep@sectioning}}%
  \codep@target@install{AddToHook}{cmd/paragraph/before}{state-only}{%
    \codep@closeparagraphifopen%
    \global\let\codep@pendingresultid\@empty%
    \global\booltrue{codep@sectioning}}%
  \codep@target@install{AddToHook}{cmd/subparagraph/before}{state-only}{%
    \codep@closeparagraphifopen%
    \global\let\codep@pendingresultid\@empty%
    \global\booltrue{codep@sectioning}}%
}%

% \codep@capturesectitle
%   Intercept \addcontentsline to capture section titles for
%   appendix-mode section grouping.  When a {toc}{section}
%   entry is written, extract the title (stripping \numberline)
%   and store it in \codep@cursecnum / \codep@cursectitle.
%   Only active in appendix mode.
%% @implements \codep@checktocsection
%@effect state-only
\newcommand*{\codep@capturesectitle}{%
  \ifbool{codep@appendix}{%
    \codep@target@install{command-wrap}{\addcontentsline}{state-only}{%
      \renewcommand{\addcontentsline}[3]{%
        \codep@orig@addcontentsline{##1}{##2}{##3}%
        \codep@checktocsection{##1}{##2}{##3}%
      }%
    }%
  }{}%
}%
% \codep@checktocsection{file}{type}{entry}
%   If file=toc and type=section, extract the section number
%   and title from the entry.  Uses \thesection for the number
%   (guaranteed correct since \refstepcounter has already run)
%   and strips \numberline from the entry via controlled \edef
%   to recover the bare title text.
%% @behavior B-REND-APPENDIX
\def\codep@checktocsection#1#2#3{%
  \def\codep@tmp@tocfile{#1}\def\codep@tmp@toctype{toc}%
  \ifx\codep@tmp@tocfile\codep@tmp@toctype%
    \def\codep@tmp@tocfile{#2}\def\codep@tmp@toctype{section}%
    \ifx\codep@tmp@tocfile\codep@tmp@toctype%
      \codep@extractsectitle{#3}%
    \fi
  \fi
}%
% \codep@extractsectitle{entry}
%   Extract the bare title from a TOC entry by redefining
%   \numberline to absorb its argument and \edef-expanding
%   the entry with \protect neutralised.
%% @implements \codep@checktocsection
\def\codep@extractsectitle#1{%
  \begingroup
    \let\protect\@empty%
    \def\numberline##1{}%
    \edef\codep@tmp@expanded{#1}%
    \global\let\codep@tmp@result\codep@tmp@expanded%
  \endgroup
  \xdef\codep@cursecnum{\thesection}%
  \global\let\codep@cursectitle\codep@tmp@result%
  \global\cslet{codep@sectitle@\thesection}\codep@tmp@result%
}%

% Auto-suppress enumitem \newlist environments.
%   When enumitem is loaded, wraps \newlist so that every
%   user-defined list environment is automatically registered
%   for paragraph-number suppression.
\newif\ifcodep@enumitemnewlistwrapped
%% @behavior B-SUPP-LISTS
%@effect state-only
\newcommand*{\codep@wrapenumitemnewlist}{%
  \ifcodep@enumitemnewlistwrapped%
  \else%
    \global\codep@enumitemnewlistwrappedtrue%
    \codep@target@install{command-wrap}{\newlist}{state-only}{%
      \gdef\newlist##1##2##3{%
        \codep@orig@newlist{##1}{##2}{##3}%
        \codep@suppressenv{##1}%
      }%
    }%
  \fi%
}%
\@ifpackageloaded{enumitem}{%
  \codep@wrapenumitemnewlist%
}{%
  \codep@target@install{AddToHook}{package/enumitem/after}{state-only}{%
    \codep@wrapenumitemnewlist%
  }%
}%
\codep@target@install{AddToHook}{begindocument/before}{state-only}{%
  \@ifpackageloaded{enumitem}{%
    \codep@wrapenumitemnewlist%
  }{}%
}

% Auto-suppress tcolorbox / mdframed environments.
%   Conditionally suppresses boxed-content environments when
%   the respective package is loaded.
%@effect state-only
\codep@target@install{AddToHook}{begindocument/before}{state-only}{%
  \@ifpackageloaded{tcolorbox}{%
    % tcolorbox emits a box-closing paragraph at \end{tcolorbox};
    % keep suppression active through AfterEndEnvironment.
    \codep@hook@install{pre-begin}{tcolorbox}{state-only}{%
      \global\advance\codep@suppressdepth\@ne%
    }%
    \codep@hook@install{after-env}{tcolorbox}{state-only}{%
      \global\advance\codep@suppressdepth\m@ne%
    }%
  }{}%
  \@ifpackageloaded{mdframed}{%
    \codep@suppressenv{mdframed}%
  }{}%
}

% \codep@suppresscommands
%   Suppress numbering inside footnote, parbox.
%   Note: \caption is NOT patched here because its complex
%   calling convention (\@ifstar + optional arg) makes
%   etoolbox patching unreliable.  Captions appear only
%   inside figure/table environments, which are already
%   suppressed at the env level.
%% @implements \codep@installsuppress
%@effect state-only
\newcommand*{\codep@suppresscommands}{%
  \codep@suppressfootnote%
  \codep@suppresscmd{\parbox}%
  \codep@suppresscmd{\maketitle}%
}

%% @behavior B-NUM-PARA
% \codep@parahook@paragraph
%   Open a paragraph atom at top level.
%@effect immediate-write
\def\codep@parahook@paragraph{%
  \codep@allocatomid{\codep@thisatomid}{paragraph}%
  \codep@ctxpush{\codep@thisatomid}{paragraph}%
  \global\codep@paragraphopentrue%
  \refstepcounter{atom}%
  \edef\codep@tmp@parakey{paragraph:\theatom}%
  \codep@atomsetkey{\codep@thisatomid}{\codep@tmp@parakey}%
  \codep@writeanchormap{\codep@tmp@parakey}%
  \codep@writeanchorpagecurrent{\codep@tmp@parakey}%
  \codep@cdpwrite@atom{%
    \string\codep@cdp@atom{\theatom}{paragraph}}%
  \codep@cdpwrite@atom{%
    \string\codep@cdp@meta{\theatom}{src}%
      {\jobname.tex:\the\inputlineno:1}}%
  \codep@registeratom{\codep@tmp@parakey}{paragraph}%
  % W03-P03: capture entitymeta for this paragraph atom.  Paragraph
  % atom-keys don't mutate after open, so open-time capture is safe.
  \codep@captureentitymeta{\codep@tmp@parakey}{paragraph}%
    {\theatom}{paragraph}{}%
  \codep@render@para@emit{\codep@tmp@parakey}{\theatom}%
}%

%% @behavior B-NUM-PARA
%% @behavior B-PROOF-ADJRULE
% \codep@installparahook
%   Install the top-level para/begin paragraph allocator.
%@effect state-only
\newcommand*{\codep@installparahook}{%
  \codep@target@install{AddToHook}{para/begin}{state-only}{%
    \ifbool{codep@tracked}{%
      \ifnum\codep@teardownpara@suppressdepth>0\relax\else%
        \codep@proof@emitpendingheadinganchor%
        \global\let\codep@pendingresultid\@empty%
        \ifcodep@proofdisplaypending%
          \codep@ctxpeekkind\codep@tmp@ctxkind%
          \def\codep@tmp@proofkind{proof}%
          \ifx\codep@tmp@ctxkind\codep@tmp@proofkind%
            \codep@proof@materialize%
          \fi%
        \fi%
        \ifbool{codep@sectioning}{%
          \global\boolfalse{codep@sectioning}%
        }{%
          \ifbool{codep@paragraphs}{%
            \ifnum\codep@suppressdepth>0\relax%
            \else\ifnum\codep@ctxdepth>0\relax%
            \else%
              \codep@parahook@paragraph%
            \fi\fi%
          }{}%
        }%
      \fi%
    }{}%
  }%
}%

%% ===================================================================
%% Section 8a: Back-reference graph (dpmac port, GPLv3)
%% ===================================================================
%%
%% Portions of this section are derived from dpmac.tex by Dmitri
%% Pavlov (Copyright 2017, 2018 Dmitri Pavlov, distributed under
%% GNU GPL version 3).  The derivative is also distributed under
%% GNU GPL version 3.  See docs/CREDITS.md for the provenance table.
%%

%% --- Section 8a.0: Reference interception (three-site design) ---
%% Per REVIEW_E finding #2 (BLOCKER), the single-\@setref patch
%% covers only \ref/\eqref/\pageref/\vref/\nameref.  cleveref's
%% \cref@getlabel, hyperref's \HyRef@autosetref (\autoref), and
%% hyperref's \HyRef@@StarSetRef (\ref*/\Ref) all bypass \@setref.
%% This subsection installs THREE patch sites.  Per REVIEW_E #16,
%% \hyperref[]{} is deliberately uncovered (manual link, not a
%% cross-reference).

% Pass-1 safety: \codep@atomref must be defined to SOMETHING at
% package-load time so that if a stale .aux still references it
% (or a user script injects a record), LaTeX's aux read does not
% error.  A \providecommand no-op suits.
\providecommand*{\codep@atomref}[2]{}

% Pass-1 safety: \codep@lbltype records label→type-prefix mappings.
% Written alongside \label, read during the aux pass to construct
% prefixed target keys in \codep@processbr.
\providecommand*{\codep@lbltype}[2]{}

% Active definition for \codep@lbltype: populates the label type
% lookup table from aux records.
%% @implements \codep@installnewlabel
\def\codep@lbltype@active#1#2{%
  \csgdef{codep@ltype@#1}{#2}}

% Pass-1 safety: \codep@anchormap records atom→hyperref anchor
% mappings.  No-op until hyperref is detected at begindocument/before.
\providecommand*{\codep@anchormap}[2]{}
\providecommand*{\codep@anchorpage}[2]{}

% Active definition for \codep@anchormap: populates the anchor lookup
% table from aux records.  Defined at package load time (outside any
% macro) so # works; activated in begindocument/before BEFORE the aux
% read, so equation range anchors are not silently discarded.
%% @implements \codep@hooktheorem
\def\codep@anchormap@active#1#2{%
  \csgdef{codep@anchor@#1}{#2}}

%% @behavior B-PASS-ONE
% \codep@anchorpage@active{key}{page}
%   Populate the in-memory anchor-start-page table from aux.
\def\codep@anchorpage@active#1#2{%
  \csxdef{codep@anchorpage@#1}{#2}}

% \codep@writeanchormap{atomnum}
%   Write an atom→anchor aux record.  No-op by default; activated
%   at \AtBeginDocument when hyperref is loaded, so the write only
%   happens when \@currentHref is meaningful.
%% @behavior B-PASS-ONE
\newcommand*{\codep@writeanchormap}[1]{}

%% @utility
% \codep@writeanchormapvalue{key}{anchor}
%   Persist an explicit key→anchor mapping.
\newcommand*{\codep@writeanchormapvalue}[2]{%
  \edef\codep@tmp@anchorval{#2}%
  \csxdef{codep@anchor@#1}{%
    \codep@tmp@anchorval}%
  \if@filesw%
    \immediate\write\@auxout{%
      \string\codep@anchormap{#1}{\codep@tmp@anchorval}}%
  \fi%
}%

%% @utility
% \codep@writeanchorpage{key}{page}
%   Persist the page where key's hyperlink anchor begins.
\newcommand*{\codep@writeanchorpage}[2]{%
  \codep@anchorpage@active{#1}{#2}%
  \if@filesw%
    % Immediate write: adjacent proof begin runs in the theorem→proof
    % gap, and a deferred \protected@write whatsit breaks amsthm's
    % adjacency glue cancellation (see W03 bug4 investigation).
    \immediate\write\@auxout{%
      \string\codep@anchorpage{#1}{#2}}%
  \fi%
}%

%% @utility
% \codep@writeanchorpagecurrent{key}
%   Persist the current page under key.
\newcommand*{\codep@writeanchorpagecurrent}[1]{%
  \edef\codep@tmp@anchorpage{\thepage}%
  \codep@writeanchorpage{#1}{\codep@tmp@anchorpage}%
}%

% Pass-1 safety for concept-tracking aux records (§9a User API).
% Active definitions installed at begindocument/before
% (§8a.9 concept resolution).
\providecommand*{\codep@concept}[2]{}
\providecommand*{\codep@conceptref}[2]{}

% Concept pending-list: deferred resolveconcept calls for
% forward refs whose def record has not yet been read.
% Flushed at begindocument/end after the full aux read.
%% @utility
\gdef\codep@conceptpending{}

% Concept name list: each concept whose \codep@emit@use
% fires at least once appends \do{name} here.  The
% \codep@conceptwarnscan at \AtEndDocument walks this list
% to detect concepts with uses but no def site.
%% @utility
\def\codep@conceptnames{}

% --- W03-P03: label->entity binding + new .aux record types ---
% Four new aux-record directives written alongside the existing
% \codep@lbltype / \codep@atomref families.  Pass-1 safety
% providecommands; active definitions installed alongside the
% existing codependent/backref/install hook.
  \providecommand*{\codep@lblentity}[2]{}
  \providecommand*{\codep@entitymeta}[5]{}
  \providecommand*{\codep@keymap}[2]{}
  \providecommand*{\codep@renderlist}[3]{}
  \providecommand*{\codep@prooftargetmeta}[4]{}

%% @behavior B-PASS-ONE
% \codep@lblentity@active{label}{atom-key}
%   Populate the in-memory label->entity binding table from an
%   aux record.  Cross-run side; same-run populate happens
%   synchronously at \codep@recordlabelowner time.
\def\codep@lblentity@active#1#2{%
  \csgdef{codep@lblentity@#1}{#2}}

%% @behavior B-PASS-ONE
% \codep@entitymeta@active{key}{kind}{display}{print-kind}{parent-key}
%   Populate per-entity metadata csnames from aux replay.  The string-ish
%   fields expand for O(1) value access; print-kind is a token-list field
%   and is stored without expansion so display-name commands survive replay.
\def\codep@entitymeta@active#1#2#3#4#5{%
  \csxdef{codep@entity@#1@kind}{#2}%
  \csxdef{codep@entity@#1@display}{#3}%
  \csgdef{codep@entity@#1@print}{#4}%
  \csxdef{codep@entity@#1@parent}{#5}}

%% @behavior B-PASS-ONE
% \codep@keymap@active{old-key}{new-key}
%   Persist atom-key renames for cross-run consumers.  Activated
%   before aux read so graph-query helpers can resolve stale proof
%   keys through the latest rebound key and so rebound proof keys
%   can alias back to their pre-rebind proof-begin anchor key.
\def\codep@keymap@active#1#2{%
  \csxdef{codep@keymap@#1}{#2}%
  \csxdef{codep@anchoralias@#2}{#1}}

%% @utility
% \codep@keymap@record{old-key}{new-key}
%   Populate the in-memory keymap immediately and persist it to
%   the aux so later runs can remap stale proof keys.
\def\codep@keymap@record#1#2{%
  \codep@keymap{#1}{#2}%
  \if@filesw%
    \protected@write\@auxout{}{%
      \string\codep@keymap{#1}{#2}}%
  \fi%
}%

%% @behavior B-PASS-ONE
% \codep@renderlist@active{key}{style}{payload}
%   Hydrate the frozen render payload from aux on begindoc-before.
%   The wire format preserves a style field for forward compat
%   (currently always "inline"; future render-style switches would
%   read it), but the only live consumer — the W3 appendix reader
%   and Moment-2 re-emit path — keys on \codep@rendered@<key>,
%   which Moment-1 also populates synchronously (see
%   \codep@render@refresh).
  \def\codep@renderlist@active#1#2#3{%
    \csgdef{codep@rendered@#1}{#3}}

  %% @utility
  % \codep@csv@count{csv}{macro}
  %   Count non-empty comma-separated items in csv.
  \def\codep@csv@count#1#2{%
    \def#2{0}%
    \edef\codep@tmp@csv{#1}%
    \ifx\codep@tmp@csv\@empty\else%
      \count@=0\relax%
      \@for\codep@tmp@csvitem:=\codep@tmp@csv\do{%
        \ifx\codep@tmp@csvitem\@empty\else%
          \advance\count@ by 1\relax%
        \fi%
      }%
      \edef#2{\the\count@}%
    \fi%
  }%

  %% @utility
  % \codep@csv@ifcontains{csv}{needle}{then}{else}
  %   Branch on exact CSV membership, preserving source order.
  \def\codep@csv@ifcontains#1#2#3#4{%
    \let\codep@tmp@csvfound\@empty%
    \edef\codep@tmp@csvneedle{#2}%
    \edef\codep@tmp@csvhaystack{#1}%
    \@for\codep@tmp@csvitem:=\codep@tmp@csvhaystack\do{%
      \ifx\codep@tmp@csvitem\@empty\else%
        \ifx\codep@tmp@csvitem\codep@tmp@csvneedle%
          \def\codep@tmp@csvfound{1}%
        \fi%
      \fi%
    }%
    \ifx\codep@tmp@csvfound\@empty%
      #4%
    \else%
      #3%
    \fi%
  }%

  %% @utility
  % \codep@csv@formatdisplay{display-csv}{macro}
  %   Format proof target-display CSV with human spaces after commas.
  \def\codep@csv@formatdisplay#1#2{%
    \let#2\@empty%
    \edef\codep@tmp@displaycsv{#1}%
    \@for\codep@tmp@displayitem:=\codep@tmp@displaycsv\do{%
      \ifx\codep@tmp@displayitem\@empty\else%
        \ifx#2\@empty%
          \edef#2{\codep@tmp@displayitem}%
        \else%
          \edef#2{#2,\space\codep@tmp@displayitem}%
        \fi%
      \fi%
    }%
  }%

  \providecommand*{\codep@prooftargetmeta}[4]{}

  %% @behavior B-PASS-ONE
  % \codep@prooftargetmeta@active{proof-key}{target-keys}{target-displays}{marker}
  %   Hydrate proof target-list metadata from aux.
  \def\codep@prooftargetmeta@active#1#2#3#4{%
    \csxdef{codep@prooftargetkeys@#1}{#2}%
    \csxdef{codep@prooftargetdisplays@#1}{#3}%
    \csxdef{codep@prooftargetmarker@#1}{#4}%
    \codep@csv@count{#2}{\codep@tmp@prooftargetcount}%
    \csxdef{codep@prooftargetcount@#1}{%
      \codep@tmp@prooftargetcount}%
    \codep@prooftargetmeta@touch{#1}%
  }%

  %% @utility
  % \codep@prooftargetmeta@getkeys{proof-key}{macro}
  %   Retrieve proof target-key CSV into macro.
  \def\codep@prooftargetmeta@getkeys#1#2{%
    \ifcsundef{codep@prooftargetkeys@#1}{%
      \let#2\@empty%
    }{%
      \letcs#2{codep@prooftargetkeys@#1}%
    }%
  }%

  %% @utility
  % \codep@prooftargetmeta@getdisplays{proof-key}{macro}
  %   Retrieve proof target-display CSV into macro.
  \def\codep@prooftargetmeta@getdisplays#1#2{%
    \ifcsundef{codep@prooftargetdisplays@#1}{%
      \let#2\@empty%
    }{%
      \letcs#2{codep@prooftargetdisplays@#1}%
    }%
  }%

  %% @utility
  % \codep@prooftargetmeta@getmarker{proof-key}{macro}
  %   Retrieve proof marker slot into macro, defaulting to *.
  \def\codep@prooftargetmeta@getmarker#1#2{%
    \ifcsundef{codep@prooftargetmarker@#1}{%
      \def#2{*}%
    }{%
      \letcs#2{codep@prooftargetmarker@#1}%
    }%
  }%

  %% @utility
  % \codep@prooftargetmeta@getcount{proof-key}{macro}
  %   Retrieve proof target count into macro.
  \def\codep@prooftargetmeta@getcount#1#2{%
    \ifcsundef{codep@prooftargetcount@#1}{%
      \def#2{0}%
    }{%
      \letcs#2{codep@prooftargetcount@#1}%
    }%
  }%

  %% @utility
  % \codep@prooftargetmeta@touch{proof-key}
  %   Add proof-key once to the enddoc metadata emission list.
  \def\codep@prooftargetmeta@touch#1{%
    \ifcsundef{codep@prooftargettouched@#1}{%
      \global\cslet{codep@prooftargettouched@#1}\@empty%
      \edef\codep@tmp@prooftargettouch{\noexpand\do{#1}}%
      \expandafter\g@addto@macro\expandafter\codep@prooftargetmetalist%
        \expandafter{\codep@tmp@prooftargettouch}%
    }{}%
  }%

  %% @utility
  % see @behavior B-PROOF-JOINT at \codep@proofof@capturejointmeta.
  % \codep@prooftargetmeta@append{proof-key}{target-key}{display}{marker}
  %   Append one target unless already present.
  \def\codep@prooftargetmeta@append#1#2#3#4{%
    \codep@prooftargetmeta@getkeys{#1}{\codep@tmp@oldtargetkeys}%
    \codep@csv@ifcontains{\codep@tmp@oldtargetkeys}{#2}{}{%
      \codep@prooftargetmeta@getdisplays{#1}{%
        \codep@tmp@oldtargetdisplays}%
      \ifx\codep@tmp@oldtargetkeys\@empty%
        \edef\codep@tmp@newtargetkeys{#2}%
        \edef\codep@tmp@newtargetdisplays{#3}%
      \else%
        \edef\codep@tmp@newtargetkeys{\codep@tmp@oldtargetkeys,#2}%
        \edef\codep@tmp@newtargetdisplays{%
          \codep@tmp@oldtargetdisplays,#3}%
      \fi%
      \codep@prooftargetmeta@active{#1}{\codep@tmp@newtargetkeys}{%
        \codep@tmp@newtargetdisplays}{#4}%
      \codep@prooftargetmeta@touch{#1}%
    }%
  }%

  %% @utility
  % \codep@prooftargetmeta@clear{proof-key}
  %   Clear same-run target metadata for proof-key.
  \def\codep@prooftargetmeta@clear#1{%
    \codep@prooftargetmeta@active{#1}{}{}{*}%
    \codep@prooftargetmeta@touch{#1}%
  }%

  %% @utility
  % \codep@prooftargetmeta@firstkey{proof-key}{macro}
  %   Return the first target key, or empty.
  \def\codep@prooftargetmeta@firstkey#1#2{%
    \codep@prooftargetmeta@getkeys{#1}{\codep@tmp@firstkeycsv}%
    \let#2\@empty%
    \@for\codep@tmp@firstkeyitem:=\codep@tmp@firstkeycsv\do{%
      \ifx#2\@empty%
        \let#2\codep@tmp@firstkeyitem%
      \fi%
    }%
  }%

  %% @utility
  % \codep@prooftargetmeta@emit@one{proof-key}
  %   Emit one aux proof-target metadata record, if non-empty.
  \def\codep@prooftargetmeta@emit@one#1{%
    \codep@prooftargetmeta@getkeys{#1}{\codep@tmp@emitkeys}%
    \ifx\codep@tmp@emitkeys\@empty\else%
      \codep@prooftargetmeta@getdisplays{#1}{\codep@tmp@emitdisplays}%
      \codep@prooftargetmeta@getmarker{#1}{\codep@tmp@emitmarker}%
      \protected@write\@auxout{}{%
        \string\codep@prooftargetmeta{#1}{\codep@tmp@emitkeys}{%
          \codep@tmp@emitdisplays}{\codep@tmp@emitmarker}}%
    \fi%
  }%

  %% @utility
  % \codep@prooftargetmeta@emit
  %   Emit final proof target metadata to aux.
  \def\codep@prooftargetmeta@emit{%
    \if@filesw%
      \begingroup%
        \let\do\codep@prooftargetmeta@emit@one%
        \codep@prooftargetmetalist%
      \endgroup%
    \fi%
  }%

  %% @utility
  % \codep@cdp@proofmeta@emit@one{proof-key}
  %   Emit one v2 proof record to .cdp, guarded against duplicates.
  \def\codep@cdp@proofmeta@emit@one#1{%
    \codep@prooftargetmeta@getkeys{#1}{\codep@tmp@cdpproofkeys}%
    \ifx\codep@tmp@cdpproofkeys\@empty\else%
      \ifcsundef{codep@cdpproofwritten@#1}{%
        \global\cslet{codep@cdpproofwritten@#1}\@empty%
        \codep@prooftargetmeta@getdisplays{#1}{%
          \codep@tmp@cdpproofdisplays}%
        \codep@prooftargetmeta@getmarker{#1}{%
          \codep@tmp@cdpproofmarker}%
        \codep@cdpwrite{%
          \string\codep@cdp@proof{#1}{\codep@tmp@cdpproofkeys}{%
            \codep@tmp@cdpproofdisplays}{\codep@tmp@cdpproofmarker}}%
      }{}%
    \fi%
  }%

  %% @utility
  % \codep@cdp@proofmeta@emit
  %   Emit final v2 proof records for all proofs with target metadata.
  \def\codep@cdp@proofmeta@emit{%
    \begingroup%
      \let\do\codep@cdp@proofmeta@emit@one%
      \codep@prooftargetmetalist%
    \endgroup%
  }%

  % Accumulator for entitymeta emission at enddoc.  Each tracked-env
% close site appends one token-sequence describing its atom; the
% enddoc drain walks the list in order and emits one aux record
% per entry.  See \codep@captureentitymeta and
% \codep@entitymeta@emit.
%% @utility
\gdef\codep@entitymetaacc{}

% \codep@entitymeta@mark is the accumulator's entry marker.
% \protected so it does NOT expand under \xdef/\edef — keeps
% each stored entry literal across subsequent accumulator
% updates.  At emit time \codep@entitymeta@emit \let's this to
% \codep@entitymeta@emit@one so expanding the accumulator fires
% the aux-write handler once per entry.
%% @utility
\protected\def\codep@entitymeta@mark#1#2#3#4#5{}%

% \codep@captureentitymeta{key}{kind}{display}{print-kind}{parent-key}
%   Record one entity's metadata for both same-run consumption
%   and cross-run persistence.  Two side effects:
%     1. Eagerly call \codep@entitymeta@active to populate the
%        in-memory \codep@entity@<key>@{kind,display,print,parent}
%        csnames.  This makes same-run consumers (notably
%        \codep@proofof@resolve during forward-ref drain) see the
%        entity before enddoc.
%     2. Append a \do-list entry to \codep@entitymetaacc for the
%        enddoc aux-write drain (cross-run replay).  The emit
%        walker binds \do to a handler and expands the accumulator.
%
%   Replay-guarded: skipped during \restatable replay so restated
%   envs don't duplicate their entry.  Defensive; in normal code
%   path the theorem-end/proof-end hooks don't fire during replay
%   anyway.
%
%   Invariant on arg #4 (print-kind): for fixed non-theorem rails
%   (proof, paragraph) callers pass the literal kind string; for the theorem
%   rail callers pass the backend's user-declared display name.
%% @utility
\def\codep@captureentitymeta#1#2#3#4#5{%
  \ifnum\codep@replaydepth>0\relax%
  \else%
    \codep@entitymeta@capture@active{#1}{#2}{#3}{#4}{#5}%
    % \xdef still expands string fields so the accumulator stores final
    % values (e.g., "theorem:1.2" or "proof:a7") rather than caller temps.
    % The existing accumulator is copied under \unexpanded, and field #4 is
    % appended under \unexpanded after one caller-temp expansion so display
    % commands (for example \textsc) survive until the protected aux write.
    \xdef\codep@entitymetaacc{%
      \unexpanded\expandafter{\codep@entitymetaacc}%
      \noexpand\codep@entitymeta@mark{#1}{#2}{#3}%
        {\unexpanded\expandafter{#4}}{#5}}%
  \fi%
}%

% \codep@entitymeta@emit@one{key}{kind}{display}{print-kind}{parent-key}
%   Per-entry handler for the emit walker.  Writes one
%   \codep@entitymeta aux record.
%% @utility
\def\codep@entitymeta@emit@one#1#2#3#4#5{%
  \protected@write\@auxout{}{%
    \string\codep@entitymeta{#1}{#2}{#3}{#4}{#5}}%
}%

% \codep@entitymeta@emit
%   Walk \codep@entitymetaacc and emit one aux record per entry.
%   Called from \codep@refpending@drain at enddoc time (commit 7).
%% @utility
\def\codep@entitymeta@emit{%
  \if@filesw%
    \begingroup%
      \let\codep@entitymeta@mark\codep@entitymeta@emit@one%
      \codep@entitymetaacc%
    \endgroup%
  \fi%
}%

% \codep@renderlist@emit@one{atom-key}{atom-kind}
%   Per-atom handler.  Guarded by the "touched this run" flag
%   \codep@rlflag@<key>, set by \codep@render@refresh's non-empty
%   branch at collapse time.  Without the flag, a warmed
%   \codep@rendered@<key> from aux-replay that was NOT refreshed
%   this run (because the atom lost its last ref) would be
%   re-serialized indefinitely — GPT MAJOR #1.  With the flag,
%   we only emit the record when the current run observed live
%   refs for this atom; next-pass .aux drops the stale entry and
%   the cache stabilizes.
%
%   Atom-kind (#2) is ignored — the wire format's style field is
%   literally "inline"; future render styles would switch here.
%   \unexpanded keeps the payload literal against \write's \edef
%   pass so the pre-rendered tokens (display text, or \hyperlink
%   wrappers from Fix 2) land in the .aux verbatim; \immediate
%   flushes at enddoc drain time, independent of shipout timing.
%% @implements \codep@renderlist@emit@all
\def\codep@renderlist@emit@one#1#2{%
  \ifcsdef{codep@rlflag@#1}{%
    \ifcsdef{codep@rendered@#1}{%
      \immediate\write\@auxout{%
        \string\codep@renderlist{#1}{inline}{%
          \expandafter\expandafter\expandafter\unexpanded%
          \expandafter\expandafter\expandafter{%
            \csname codep@rendered@#1\endcsname}}}%
    }{}%
  }{}%
}%

% \codep@renderlist@emit@all
%   Walk the count-indexed atom array and emit renderlist records
%   for every atom with a populated Moment-1 cache.  Array entries
%   expand to {<prefixed-key>}{<kind>}; the triple-\expandafter
%   chain resolves the csname before emit@one sees its args.
%% @behavior B-PASS-ONE
\def\codep@renderlist@emit@all{%
  \if@filesw%
    \begingroup%
      \count@=\z@%
      \loop%
        \ifnum\count@<\codep@atomcount%
        \advance\count@ by 1\relax%
        \expandafter\expandafter\expandafter%
          \codep@renderlist@emit@one%
          \csname codep@atom@\the\count@\endcsname%
      \repeat%
    \endgroup%
  \fi%
}%

% Label-key set for the pending forward-ref list.  Each entry is
% \do{label}; per-label token lists live in the separate
% \codep@refpending@<label> csname family.  Appended to (per label)
% by \codep@defer@proofof at proofof-time when the referenced label
% has not yet been seen; walked by \codep@refpending@drain at
% enddoc to replay deferred resolutions against the now-complete
% label->entity binding.
%% @utility
\gdef\codep@refpendinglabels{}

% \codep@defer@proofof{resolver}{proofid}{label}{anchormode}
%   Queue a deferred \codepproofof resolution against <label>.  The
%   proof-id is expanded NOW so the drain has the originating
%   proof's atom-id even if \codep@currentproofid has moved on by
%   drain time.  Resolver, label, and anchormode are preserved.
%
%   Replay-guarded: skipped during \restatable replay.  Deferrals
%   are a pass-1 mechanism; replay should not duplicate queued
%   tokens (the originating proofof call would have already been
%   processed or deferred in the non-replay pass).
%% @utility
\def\codep@defer@proofof#1#2#3#4{%
  \ifnum\codep@replaydepth>0\relax%
  \else%
    \ifcsundef{codep@refpending@#3}{%
      \csxdef{codep@refpending@#3}{%
        \noexpand#1{#2}{\unexpanded{#3}}{\unexpanded{#4}}}%
      \g@addto@macro\codep@refpendinglabels{\do{#3}}%
    }{%
      \edef\codep@tmp@proofpending{%
        \noexpand#1{#2}{\unexpanded{#3}}{\unexpanded{#4}}}%
      \expandafter\g@addto@macro%
        \csname codep@refpending@#3\endcsname%
        \expandafter{\codep@tmp@proofpending}%
    }%
  \fi%
}%

% \codep@drainrefpending{label}
%   Replay any deferred-resolution tokens queued against this label.
%   Called from \codep@refpending@drain.  No-op if no tokens queued.
%   Clears the per-label csname after execution so a second drain
%   pass (defensive) would be a no-op.
%% @utility
\def\codep@drainrefpending#1{%
  \ifcsundef{codep@refpending@#1}{}{%
    \csuse{codep@refpending@#1}%
    \csgundef{codep@refpending@#1}%
  }%
}%

% \codep@refpending@drain
%   P03's enddoc-drain body.  Invoked by \codep@enddoc@orchestrator's
%   drain@p03 slot (Section 9b); no direct \AtEndDocument here.
%
%   Two responsibilities, in order:
%     1. Emit the entitymeta accumulator to the .aux so cross-run
%        readers can repopulate the in-memory entity bindings at
%        next-run begindoc time.
%     2. Drain any pending \codepproofof forward-refs whose target
%        labels are now known (same-run late-resolution); remaining
%        truly-unknown labels warn inside \codep@proofof@resolve.
%% @behavior B-PASS-ONE
%% @behavior B-PROOF-SEP
\def\codep@refpending@drain{%
  \codep@entitymeta@emit%
  \begingroup%
    \let\do\codep@drainrefpending%
    \codep@refpendinglabels%
  \endgroup%
  \codep@prooftargetmeta@emit%
  \codep@cdp@proofmeta@emit%
}%

% P04: \codep@refpending@drain is called from within
% \codep@enddoc@orchestrator (declared in Section 9b, below).
% No direct \AtEndDocument registration here — the orchestrator
% is the single enddocument entry-point.

% \codep@writeatomref{target}
%   Shared aux-write helper called by all patch sites.  Guards
%   on \codep@currentatom (in-atom sentinel: empty = not inside
%   a tracked atom, so no write) and on \if@filesw so --draftmode
%   / -no-aux compiles work.  The src field is normally read from
%   \theatom at write time per docs/DESIGN.md §8a.5.0.  However, when
%   \codep@sourceatom is non-empty (adjacent proofs), it overrides
%   \theatom to emit starred atom numbers (e.g. "2.1*").
%
%   Bug-fix guards (2026-04-11):
%   (a) \ifmeasuring@ — amsmath processes align/gather/multline/
%       flalign bodies twice (measuring + typesetting).  Skip
%       entirely during the measuring pass so no dedup marks are
%       set and no writes are emitted.  \ifmeasuring@ is defined
%       by amsmath; guarded with \ifcsundef for non-amsmath docs.
%   (b) Per-(source, target) dedup — \cref{label} fires both
%       \cref@getlabel (patch 2) and \@setref (patch 1), producing
%       doubled \codep@atomref records.  A csname flag
%       codep@arw@<src>@<tgt> blocks the second write.
% \codep@writeatomref@do{target}
%   Normal (non-equation) aux-write path.  Extracted from the
%   original \codep@writeatomref body so equation branches can
%   fall through to it.
%% @implements \codep@writeatomref
\def\codep@writeatomref@do#1{%
  \codep@writerefevent{#1}%
}%

%% @behavior B-PASS-ONE
\def\codep@writeatomref#1{%
  % (a) Skip during amsmath measuring pass.
  \ifcsundef{ifmeasuring@}%
    {\codep@writeatomref@body{#1}}%
    {\ifmeasuring@\else\codep@writeatomref@body{#1}\fi}%
}

% \codep@writeatomref@tracktwo{target}
%   Track 2 (align/gather multiline) path: defer the ref
%   to the pending list for later flush by \codep@flusheqrange.
%   SW5c commit 3 keeps the \codep@arw@pending@<tgt> guard as
%   belt-and-braces: each target is enqueued at most once per
%   multiline block even though the resolved-backend wrappers are gone.
%% @implements \codep@writeatomref
\def\codep@writeatomref@tracktwo#1{%
  \codep@eqshouldtrack%
  \ifx\codep@eqatom\@empty%
    \codep@writeatomref@do{#1}%
  \else%
    \ifcsundef{codep@arw@pending@#1}{%
      \global\cslet{codep@arw@pending@#1}\@empty%
      \global\codep@eqpendguards=\expandafter{%
        \the\codep@eqpendguards%
        \global\expandafter\let%
          \csname codep@arw@pending@#1\endcsname\relax}%
      \global\codep@eqpending=\expandafter{%
        \the\codep@eqpending\codep@eqpending@entry{#1}}%
      \global\advance\codep@eqpendingcount by 1\relax%
    }{}%
  \fi%
}%

% \codep@writeatomref@trackone{target}
%   Track 1 (single equation) path: record the ref directly
%   with the parenthesized equation number.
%% @implements \codep@writeatomref
\def\codep@writeatomref@trackone#1{%
  \codep@eqshouldtrack%
  \ifx\codep@eqatom\@empty%
    \codep@writeatomref@do{#1}%
  \else%
    \edef\codep@eqatom{equation:\theequation}%
    \ifx\codep@currenteqsourceid\@empty\else%
      \codep@atomsetkey{\codep@currenteqsourceid}{\codep@eqatom}%
    \fi%
    \codep@writeanchormap{\codep@eqatom}%
    \if@filesw%
      \codep@dedupwrite{\codep@eqatom}{#1}%
    \fi%
  \fi%
}%

%% @implements \codep@writeatomref
\def\codep@writeatomref@body#1{%
  \ifbool{codep@inequation}{%
    \ifbool{codep@eqmultiline}{%
      \codep@writeatomref@tracktwo{#1}%
    }{%
      \codep@writeatomref@trackone{#1}%
    }%
  }{%
    \codep@writeatomref@do{#1}%
  }%
}%

%% --- Section 8a.1: Defer queue (csname linked list) ---
%% Per REVIEW_C finding #2, the toks-register pattern from dpmac
%% is O(N^2) at 15k refs; replaced with a csname linked list
%% keyed by a monotonic \codep@brid counter.

\newcount\codep@brid
\codep@brid=0\relax

% \codep@recordbr{src}{tgt}
%   Enqueue a processbackref call.  O(1) per append.
%% @behavior B-EDGE-PROOF-ANY
\def\codep@recordbr#1#2{%
  \global\advance\codep@brid by 1\relax
  \csxdef{codep@brq@\the\codep@brid}{%
      \noexpand\codep@processbr{#2}{#1}%
    }%
}

% \codep@flushbrqueue
%   Walk the linked list once, O(N) total.  Called from the
%   begindocument/end hook (Section 8a.7).
%% @behavior B-DISP-THM
\def\codep@flushbrqueue{%
  \begingroup
    \count@=\z@%
    \loop%
      \ifnum\count@<\codep@brid%
        \advance\count@ by 1\relax
        \csuse{codep@brq@\the\count@}
        \global\expandafter\let%
          \csname codep@brq@\the\count@\endcsname\relax
    \repeat%
  \endgroup
}

%% --- Section 8a.2: Active aux-record callback ---
%% The \providecommand no-op from Section 8a.0 is REPLACED by
%% this active definition at begindocument/before (Section
%% 8a.7), before LaTeX reads .aux in \begin{document}.  From
%% that point on, every \codep@atomref{src}{tgt} that the .aux
%% read fires lands here and enqueues a processbackref call.
%%
%% Per REVIEW_C finding #4, guard on empty src (orphan refs
%% emitted between atoms).  Belt-and-braces: the front-edge and
%% other live write sites already skip the write when the current
%% atom is empty.

%% @behavior B-PASS-ONE
\def\codep@atomref@active#1#2{%
  \edef\codep@tmp@src{#1}%
  \ifx\codep@tmp@src\@empty\else
    \codep@recordbr{#1}{#2}%
  \fi
}

%% --- Section 8a.2a: Type-prefixed key helpers ---
%% All backref graph keys carry a type prefix (envname:, paragraph:,
%% equation:, proof:) to prevent display-number collisions between
%% different atom types that share a numbering scheme (e.g.
%% equation 2.1 vs paragraph 2.1).  Internal csnames use the full
%% prefixed key; the display form is derived by stripping the
%% prefix and applying type-specific formatting.

%% @utility
% \codep@splitprefix{type:num}
%   Split a prefixed key into \codep@tmp@type and \codep@tmp@num.
%   The key format is "type:number" where type is one of
%   thm, para, eq, proof.
\def\codep@splitprefix#1:#2\@nil{%
  \def\codep@tmp@type{#1}%
  \def\codep@tmp@num{#2}%
}%

%% @utility
% \codep@ifunresrefkey{key}{then}{else}
%   Branch on the unresolved-reference source namespace prefix.
\def\codep@ifunresrefkey#1#2#3{%
  \edef\codep@tmp@ifunresrefkey{#1}%
  \expandafter\codep@ifunresrefkey@aux\codep@tmp@ifunresrefkey:\@nil{#2}{#3}%
}%

%% @utility
% \codep@ifunresrefkey@aux key-prefix splitter.
\def\codep@ifunresrefkey@aux#1:#2\@nil#3#4{%
  \def\codep@tmp@ifunresrefprefix{#1}%
  \ifx\codep@tmp@ifunresrefprefix\codep@const@typeunresref%
    #3%
  \else%
    #4%
  \fi%
}%

% Display-key formatting (\codep@displayfromkey, type constants)
% moved to codependent-render.sty.  Tracking code uses only
% \codep@splitprefix (above) for key decomposition.

%% --- Section 8a.3: Per-target linked list, processbr, collapsebr ---
%% For each target atom we maintain:
%%   \codep@brcount@<num>     -- count of appended refs
%%   \codep@brnode@<num>@<k>  -- the k-th ref text (prefixed key)
%% At typeset time the nodes are collapsed into the display
%% macro \codep@br@<num>.  Per REVIEW_C finding #2 second half,
%% this turns O(degree^2) into O(degree).

%% @implements \codep@processbr
% \codep@appendbr@core
%   Shared body for \codep@processbr and \codep@appendbr.
%   Precondition: \codep@tmp@tgt and \codep@tmp@src are already
%   \edef'd to the resolved display numbers.
%   Performs: self-ref guard, consecutive-dedup, lazy count
%   init, linked-list node store.
\def\codep@appendbr@core{%
  % Defensive fallback: ordinary unresref body refs are migrated earlier by
  % \codep@unresref@flushrefs.  If a provisional source reaches replay anyway,
  % rewrite it through the resolved keymap before self-ref/dedup handling.
  \codep@ifunresrefkey{\codep@tmp@src}{%
    \ifcsundef{codep@keymap@\codep@tmp@src}{%
    }{%
      \edef\codep@tmp@src{%
        \csuse{codep@keymap@\codep@tmp@src}}%
    }%
  }{}%
  % Self-ref guard (REVIEW_C finding #10).
  \ifx\codep@tmp@src\codep@tmp@tgt\else
    % Dedup against previous append for this target.
    \edef\codep@tmp@last{%
      \csuse{codep@brlast@\codep@tmp@tgt}}%
    \ifx\codep@tmp@last\codep@tmp@src%
      % Consecutive duplicate: skip.
    \else
      \global\cslet{codep@brlast@\codep@tmp@tgt}\codep@tmp@src%
      % Append a new linked-list node.
      \ifcsundef{%
          codep@brcount@\codep@tmp@tgt}{%
        \csgdef{codep@brcount@\codep@tmp@tgt}{0}%
      }{}%
      \edef\codep@tmp@k{%
        \csuse{codep@brcount@\codep@tmp@tgt}}%
      \count@=\codep@tmp@k\relax
      \advance\count@ by 1\relax
      \csxdef{codep@brcount@\codep@tmp@tgt}%
        {\the\count@}%
      \csxdef{codep@brnode@\codep@tmp@tgt @\the\count@}%
        {\codep@tmp@src}%
    \fi
  \fi
}%

%% @behavior B-LINK-EFFECTIVE-ANCHOR
%% @behavior B-PASS-TWO
%% @behavior B-SELFREF
% \codep@processbr{tgt}{src}
%   #1 = target label key (resolves to canonical atom-key via
%        lblentity, or falls back to ltype:lblnum for stale aux)
%   #2 = source atom prefixed key (e.g. thm:2.1, para:1.3)
%   Prefers \codep@lblentity@<label> (canonical atom-key written
%   by W03-P03 enddoc) so standalone proofs whose label binds to
%   the surrounding paragraph counter (lblnum=para number) still
%   resolve to their opaque atom-key (proof:a<N>) rather than
%   the wrong "proof:<para-num>".  Falls through to legacy
%   ltype:lblnum if lblentity is unavailable (pre-W03-P03 aux,
%   or labels written outside the codependent label hook).
\def\codep@processbr#1#2{%
  \ifcsundef{codep@lblentity@#1}{%
    \ifcsundef{codep@lblnum@#1}{%
      % Unknown target: silently drop.
    }{%
      \ifcsundef{codep@ltype@#1}{%
        \edef\codep@tmp@tgt{\csuse{codep@lblnum@#1}}%
      }{%
        \edef\codep@tmp@tgt{%
          \csuse{codep@ltype@#1}
          :\csuse{codep@lblnum@#1}}%
      }%
      \edef\codep@tmp@src{#2}%
      \codep@appendbr@core%
    }%
  }{%
    \edef\codep@tmp@tgt{\csuse{codep@lblentity@#1}}%
    \edef\codep@tmp@src{#2}%
    \codep@appendbr@core%
  }%
}

%% @implements \codep@processbr
% \codep@appendbr{tgtnum}{srcnum}
%   Append a backref edge directly using display numbers
%   (no lblnum lookup).  Used by concept resolution where
%   both source and target atom numbers are already known.
%   Includes self-ref and consecutive-dedup guards.
\def\codep@appendbr#1#2{%
  \edef\codep@tmp@tgt{#1}%
  \edef\codep@tmp@src{#2}%
  \codep@appendbr@core%
}

% \codep@collapsebr — moved to codependent-render.sty.

%% --- Section 8a.3a: Rendering query API shims ---
%% These macros form the render barrier: codependent-render.sty
%% calls ONLY these to read graph state.  The implementations
%% wrap the current prefixed-key internals (codep@brcount@,
%% codep@brnode@, codep@anchor@, \codep@splitprefix).  In later
%% waves the shim bodies change but the signatures stay fixed.

% String constants for type comparisons in display rules.
% Needed by \codep@graph@getdisplay; previously in render.sty.
%% @utility
\def\codep@const@typeequation{equation}%
%% @utility
\def\codep@const@typeproof{proof}%
%% @utility
\def\codep@const@typeunresref{unresref}%

%% @utility
% \codep@graph@resolvekey{entity-key}{macro}
%   Follow a one-hop key rename through \codep@keymap@<old>.
\def\codep@graph@resolvekey#1#2{%
  \ifcsundef{codep@keymap@#1}{%
    \edef#2{#1}%
  }{%
    \letcs#2{codep@keymap@#1}%
  }%
}%

%% @utility
% \codep@graph@hasrefs{target-key}{then}{else}
%   Test whether the target has at least one backref edge.
%   #1 = target key (prefixed key like "theorem:1.2")
%   #2 = then branch
%   #3 = else branch
\def\codep@graph@hasrefs#1#2#3{%
  \ifcsundef{codep@brcount@#1}{%
    #3%
  }{%
    #2%
  }%
}%

%% @utility
% \codep@graph@getdisplay{entity-key}{macro}
%   Derive the rendered display form from a prefixed key and
%   store it in #2 as a self-contained snapshot.  The equation
%   and proof branches use \edef so \codep@tmp@num resolves at
%   definition time, not consumer time — critical for callers
%   that \let or \unexpanded the result macro (e.g. the
%   collapsebr accumulator, which iterates and mutates
%   \codep@tmp@num between sibling callbacks).  The theorem
%   branch already snapshots via \let-meaning.
%
%   Proof display gates on proof target metadata:
%     one target      → "N.M*"          ("N.M" when proofs=off)
%     multiple targets → "{N.M, N.K}*"  ("{N.M, N.K}" when proofs=off)
%   Standalone proofs carry the same stable proof:a<N> key but have
%   no target metadata; they are suppressed upstream by
%   \codep@collapsebr@cb's classifier.
%
%   equation:X → (X)
%   proof:X    → X* | X (per proofs=on|off)
%   otherwise  → X
%% @behavior B-DISP-PROOF
%% @behavior B-DISP-EQ
%% @behavior B-PROOF-OFF
\def\codep@graph@getdisplay#1#2{%
  \expandafter\codep@splitprefix#1\@nil%
  \ifx\codep@tmp@type\codep@const@typeequation%
    \edef#2{(\codep@tmp@num)}%
  \else\ifx\codep@tmp@type\codep@const@typeproof%
    \codep@prooftargetmeta@getdisplays{#1}{\codep@tmp@proofdisplays}%
    \ifx\codep@tmp@proofdisplays\@empty%
      \codep@graph@getentitydisplay{#1}{\codep@tmp@proofentitydisplay}%
      \ifx\codep@tmp@proofentitydisplay\@empty%
        \ifbool{codep@proofsnumbered}%
          {\edef#2{\codep@tmp@num*}}%
          {\let#2\codep@tmp@num}%
      \else%
        \let#2\codep@tmp@proofentitydisplay%
      \fi%
    \else%
      \codep@prooftargetmeta@getcount{#1}{\codep@tmp@proofdisplaycount}%
      \codep@prooftargetmeta@getmarker{#1}{\codep@tmp@proofmarker}%
      \codep@csv@formatdisplay{\codep@tmp@proofdisplays}{%
        \codep@tmp@proofformatted}%
      \ifnum\codep@tmp@proofdisplaycount>1\relax%
        \ifbool{codep@proofsnumbered}%
          {\edef#2{\{\codep@tmp@proofformatted\}\codep@tmp@proofmarker}}%
          {\edef#2{\{\codep@tmp@proofformatted\}}}%
      \else%
        \ifbool{codep@proofsnumbered}%
          {\edef#2{\codep@tmp@proofformatted\codep@tmp@proofmarker}}%
          {\let#2\codep@tmp@proofformatted}%
      \fi%
    \fi%
  \else\ifx\codep@tmp@type\codep@const@typeunresref%
    \edef#2{?u\codep@tmp@num*}%
  \else%
    \let#2\codep@tmp@num%
  \fi\fi\fi%
}%

%% @utility
% \codep@graph@getanchor{entity-key}{macro}
%   Retrieve the hyperref anchor for entity-key into #2,
%   or set #2 to \@empty if no anchor exists.
%
%   Rebound-proof keys alias first: if key was produced by a
%   \codep@keymap old->new rename, chase that alias back to the
%   pre-rebind key so the visible proof:N.M key resolves through
%   the original proof-begin anchor.  Otherwise do the usual
%   local-first lookup, falling back through the forward keymap
%   rail when only a newer key recorded an anchor.
\def\codep@graph@getanchor#1#2{%
  \ifcsundef{codep@anchoralias@#1}{%
    \ifcsundef{codep@anchor@#1}{%
      \codep@graph@resolvekey{#1}\codep@tmp@graphkey%
      \ifcsundef{codep@anchor@\codep@tmp@graphkey}{%
        \let#2\@empty%
      }{%
        \letcs#2{codep@anchor@\codep@tmp@graphkey}%
      }%
    }{%
      \letcs#2{codep@anchor@#1}%
    }%
  }{%
    \edef\codep@tmp@graphalias{%
      \csuse{codep@anchoralias@#1}}%
    \codep@graph@getanchor{\codep@tmp@graphalias}{#2}%
  }%
}%

%% @utility
% \codep@graph@getkind{entity-key}{macro}
%   Extract the type prefix from a prefixed key into #2.
\def\codep@graph@getkind#1#2{%
  \expandafter\codep@splitprefix#1\@nil%
  \let#2\codep@tmp@type%
}%

%% @utility
% \codep@graph@getentitydisplay{entity-key}{macro}
%   Retrieve the entitymeta display field for entity-key into #2.
\def\codep@graph@getentitydisplay#1#2{%
  \expandafter\let\expandafter#2%
    \csname codep@entity@#1@display\endcsname%
  \ifx#2\relax\let#2\@empty\fi%
}%

%% @utility
% \codep@graph@getprintkind{entity-key}{macro}
%   Retrieve the entitymeta print-kind field for entity-key into #2.
\def\codep@graph@getprintkind#1#2{%
  \expandafter\let\expandafter#2%
    \csname codep@entity@#1@print\endcsname%
  \ifx#2\relax\let#2\@empty\fi%
}%

%% @utility
% \codep@graph@getanchorpage{entity-key}{macro}
%   Retrieve the anchor-start page for entity-key into #2.
\def\codep@graph@getanchorpage#1#2{%
  \expandafter\let\expandafter#2%
    \csname codep@anchorpage@#1\endcsname%
  \ifx#2\relax\let#2\@empty\fi%
}%

%% @utility
% \codep@graph@getentityparent{entity-key}{macro}
%   Retrieve the entitymeta parent-key field for entity-key into #2,
%   or set #2 to \@empty if no entity record is bound or the parent
%   slot is empty.  Used by the rendering classifier to distinguish
%   ADJACENT / REBOUND proofs (non-empty parent) from STANDALONE
%   proofs (empty parent) when deciding source-token visibility.
%
%   Intentionally does NOT call \codep@graph@resolvekey: the parent
%   slot is only populated by the adjacent (\codep@proof@adjacent →
%   \codep@bindproofparent) and rebound (\codep@proofof@resolve)
%   paths, both of which write directly to the post-rebind key.
%   So the keymap rail never needs to be consulted to find a parent
%   record — the record always lives at the final key.
\def\codep@graph@getentityparent#1#2{%
  \expandafter\let\expandafter#2%
    \csname codep@entity@#1@parent\endcsname%
  \ifx#2\relax%
    \let#2\@empty%
  \fi%
  \ifx#2\@empty%
    \codep@prooftargetmeta@firstkey{#1}{#2}%
  \fi%
}%

%% @utility
% \codep@graph@foreachref{target-key}{callback}
%   Iterate over all source refs for target-key, calling
%   #2{source-key} for each.  #2 is a macro that takes one arg.
\def\codep@graph@foreachref#1#2{%
  \ifcsundef{codep@brcount@#1}{}{%
    \edef\codep@tmp@n{\csuse{codep@brcount@#1}}%
    \count@=\z@%
    \loop%
      \ifnum\count@<\codep@tmp@n%
        \advance\count@ by 1\relax%
        \edef\codep@tmp@node{%
          \csuse{codep@brnode@#1@\the\count@}}%
        \expandafter#2\expandafter{\codep@tmp@node}%
    \repeat%
  }%
}%

%% @utility
% \codep@render@equationblock{source-atom-id}{fallback-atom-id}{target-list}
%   Wave 1 pass-through shim for equation rendering.
%   #1 = source atom id (prefixed eq key, e.g. "equation:1")
%   #2 = fallback atom id (empty or enclosing atom key)
%   #3 = target list as \do{q1}\do{q2}...
%   In the current architecture equation rendering is already
%   handled by \codep@render@refresh called from the
%   tracking hooks, so this shim is intentionally empty.
%   The real implementation lands in Wave 2/3.
\def\codep@render@equationblock#1#2#3{}%

%% --- Section 8a.4: \newlabel / \newlabelxx override + extractor ---
%% Per REVIEW_C finding #1, use a \@secondoftwo-style grab of
%% the first braced subgroup.  Per REVIEW_C finding #3, install
%% at begindocument/before so hyperref's pre-2023 aux-injection
%% block does not clobber it.  Also override \newlabelxx for
%% the pre-2023 hyperref pathway.

%% @implements \codep@extractlblnum
% \codep@grabfirst#1#2\@nil -> #1
%   Grab the first brace group of a delimited argument.
\def\codep@grabfirst#1#2\@nil{#1}

%% @implements \codep@extractanchor
% \codep@grab4th#1#2#3#4#5\@nil -> #4
%   Grab the 4th brace group.  Used to extract hyperref's
%   anchor name from \newlabel's value ({num}{page}{title}{anchor}{}).
\def\codep@grab4th#1#2#3#4#5\@nil{#4}

%% @behavior B-LINK-EFFECTIVE-ANCHOR
% \codep@extractanchor{key}{value}
%   Extract hyperref's anchor (4th field of \newlabel value)
%   and store a reverse mapping: atom number -> anchor name.
%   No-ops for @cref keys or when value has fewer than 4 fields.
\def\codep@extractanchor#1#2{%
  \codep@ifcrefkey{#1}{}{%
    \codep@ifdatakey{#1}{}{%
      \expandafter\codep@extractanchor@ii%
        \expandafter{\codep@grab4th#2{}{}{}{}\@nil}{#1}%
    }%
  }%
}
%% @behavior B-LINK-EFFECTIVE-ANCHOR
% \codep@writeanchoreff{label}{ltype}{display}{anchor}
%   Write the effective anchor mapping under the normalized target key.
\def\codep@writeanchoreff#1#2#3#4{%
  \edef\codep@tmp@anchorltype{#2}%
  \edef\codep@tmp@anchordisp{#3}%
  \edef\codep@tmp@anchorval{#4}%
  \ifx\codep@tmp@anchorltype\@empty%
    \csxdef{codep@anchor@\codep@tmp@anchordisp}{%
        \codep@tmp@anchorval}%
  \else%
    \edef\codep@tmp@prefixed{%
      \codep@tmp@anchorltype:\codep@tmp@anchordisp}%
    \csxdef{codep@anchor@\codep@tmp@prefixed}{%
        \codep@tmp@anchorval}%
  \fi%
}%
%% @implements \codep@writeanchoreff
\def\codep@extractanchor@ii#1#2{%
  % #1 = anchor (4th field or empty), #2 = label key
  \def\codep@tmp@anchorfield{#1}%
  \ifx\codep@tmp@anchorfield\@empty\else%
    \ifcsundef{codep@lblnum@#2}{}{%
      % Resolve atom number first, then define the anchor mapping
      % using the prefixed key (type:number).
      \protected@edef\codep@tmp@num{%
        \csuse{codep@lblnum@#2}}%
      % Build prefixed key from type map if available.
      \ifcsundef{codep@ltype@#2}{%
        \let\codep@tmp@anchorltype\@empty%
      }{%
        \edef\codep@tmp@anchorltype{%
          \csuse{codep@ltype@#2}}%
      }%
      \codep@writeanchoreff{#2}{\codep@tmp@anchorltype}%
        {\codep@tmp@num}{#1}%
    }%
  \fi%
}%
%% @utility
% \codep@ifdatakey{key}{then}{else}
%   True iff the label key ends in "@data" (thm-restate internal).
%   These contain \setcounter calls, not display numbers.
\def\codep@ifdatakey#1{%
  \codep@isdatafalse%
  \def\codep@ifdatakey@probe##1@data##2\@nil{%
    \def\codep@tmp@datasuffix{##2}%
    \ifx\codep@tmp@datasuffix\@empty\else
      \def\codep@tmp@datasentinel{@data}%
      \ifx\codep@tmp@datasuffix\codep@tmp@datasentinel%
        \codep@isdatatrue%
      \fi
    \fi
  }%
  \codep@ifdatakey@probe#1@data\@nil%
  \ifcodep@isdata%
    \expandafter\@firstoftwo%
  \else
    \expandafter\@secondoftwo%
  \fi
}

% Flag used only inside \codep@ifcrefkey.
\newif\ifcodep@iscref
% Flag used only inside \codep@ifdatakey (separate from \ifcodep@iscref).
\newif\ifcodep@isdata

%% @behavior B-PASS-ONE
%@effect state-only
\def\codep@installnewlabel{%
  \codep@target@install{command-wrap}{\newlabel}{state-only}{%
    \def\newlabel##1##2{%
      \codep@orig@newlabel{##1}{##2}%
      \codep@extractlblnum{##1}{##2}%
      \codep@extractanchor{##1}{##2}%
    }%
  }%
  % Pre-2023 hyperref path: \newlabelxx has 6 args.  Hyperref
  % installs it in \AtBeginDocument and it races with our
  % override, so we override it too.
  \ifcsundef{newlabelxx}{}{%
    \codep@target@install{command-wrap}{\newlabelxx}{state-only}{%
      \def\newlabelxx##1##2##3##4##5##6{%
        \codep@orig@newlabelxx%
          {##1}{##2}{##3}{##4}{##5}{##6}%
        % ##2 is already the display number for the 6-arg form.
        \csgdef{codep@lblnum@##1}{##2}%
        % ##5 is the hyperref anchor name; store reverse mapping
        % using prefixed key if type is known.
        \codep@ifcrefkey{##1}{}{%
          \def\codep@tmp@anchorval{##5}%
          \ifx\codep@tmp@anchorval\@empty\else%
            \ifcsundef{codep@ltype@##1}{%
              \let\codep@tmp@anchorltype\@empty%
            }{%
              \edef\codep@tmp@anchorltype{%
                \csuse{codep@ltype@##1}}%
            }%
            \codep@writeanchoreff{##1}{\codep@tmp@anchorltype}{##2}{##5}%
          \fi%
        }%
      }%
    }%
  }%
}

%% @behavior B-PASS-ONE
% \codep@extractlblnum{key}{value}
%   value is the raw 2nd arg of \newlabel; after TeX brace-
%   stripping it is "{num}{page}{...}{...}{...}".  Grab the
%   first brace group and stash it under the key.  Skip keys
%   that END in @cref (cleveref internal records).
\def\codep@extractlblnum#1#2{%
  \codep@ifcrefkey{#1}{%
    % @cref-suffixed: skip silently.
  }{%
    \expandafter\codep@extractlblnum@ii%
      \expandafter{\codep@grabfirst#2\@nil}{#1}%
  }%
}
%% @implements \codep@extractlblnum
\def\codep@extractlblnum@ii#1#2{%
  \csgdef{codep@lblnum@#2}{#1}%
}

%% @utility
% Sentinel used by \codep@ifcrefkey.
\def\codep@ifcrefsentinel{@cref}

%% @utility
% \codep@ifcrefkey{key}{then}{else}
%   True iff the label key ENDS in "@cref".  Per REVIEW_D
%   finding #4, matching "any key containing @cref" incorrectly
%   dropped keys like "lemma@crefnum".  The delimited-arg probe
%   splits "<key>@cref\@nil" on the FIRST occurrence of "@cref";
%   the key ends in @cref iff the tail is exactly "@cref".
\def\codep@ifcrefkey#1{%
  \codep@iscreffalse%
  \def\codep@ifcrefkey@probe##1@cref##2\@nil{%
    \def\codep@tmp@crefsuffix{##2}%
    \ifx\codep@tmp@crefsuffix\@empty%
      % No @cref in the key at all; the probe's own trailing
      % @cref absorbed the split -> NOT a cref key.
    \else
      \ifx\codep@tmp@crefsuffix\codep@ifcrefsentinel%
        \codep@iscreftrue%
      \fi
    \fi
  }%
  \codep@ifcrefkey@probe#1@cref\@nil%
  \ifcodep@iscref%
    \expandafter\@firstoftwo%
  \else
    \expandafter\@secondoftwo%
  \fi
}

%% --- Section 8a.7: Hook installation ---
%% Per REVIEW_D finding #2, codependent-owned labels on
%% begindocument/before get EXPLICIT relative ordering rather
%% than both claiming "before *".  The \DeclareHookRule below
%% pins \codep/backref/install to run before hyperref.

% Install the \newlabel override AND the active aux callbacks at
% begindocument/before so they are live before the .aux read in
% \begin{document}.
%@effect state-only
\codep@target@install{AddToHook}{begindocument/before}{state-only}{%
  \codep@installnewlabel
  % Swap the providecommand no-ops for the active callbacks.
  \codep@activation@let@install{\codep@atomref}{\codep@atomref@active}%
  \codep@activation@let@install{\codep@lbltype}{\codep@lbltype@active}%
  % Activate P03 in-memory/aux binding readers BEFORE the aux read
  % so cross-run binding + entity metadata records are captured.
  \codep@activation@let@install{\codep@lblentity}{\codep@lblentity@active}%
  \codep@activation@let@install{\codep@entitymeta}{\codep@entitymeta@active}%
  \codep@activation@let@install{\codep@keymap}{\codep@keymap@active}%
  \codep@activation@let@install{\codep@renderlist}{\codep@renderlist@active}%
  \codep@activation@let@install{\codep@prooftargetmeta}{\codep@prooftargetmeta@active}%
  \codep@activation@let@install{\codep@anchorpage}{\codep@anchorpage@active}%
  % Activate anchormap BEFORE aux read so equation range anchors
  % like \codep@anchormap{equation:4.4--4.5}{codep.eq.3} are not discarded.
  \@ifpackageloaded{hyperref}{%
    \codep@activation@let@install{\codep@anchormap}{\codep@anchormap@active}%
  }{}%
}

%% --- Section 8a.9: Concept-aware forward-reference resolution ---
%% Active callbacks for \codep@concept and \codep@conceptref.
%% Defined here (at package-load time, under \makeatletter);
%% swapped in at begindocument/before by \let, following the
%% same pattern as \codep@atomref@active.

%% @behavior B-CONC-DEFSITE
% \codep@concept@active{name}{atomnum}
%   Populate the concept def-site map.  Per J3, silently
%   overwrite on duplicate aux records (stale prior-run).
\def\codep@concept@active#1#2{%
  \csgdef{codep@conceptdef@#1}{#2}%
}

%% @behavior B-CONC-FWDREF
% \codep@conceptref@active{srcatom}{conceptname}
%   If the def site is already in the concept map, resolve
%   immediately; otherwise defer to \codep@conceptpending
%   for retry after the full aux read completes.
\def\codep@conceptref@active#1#2{%
  \ifcsundef{codep@conceptdef@#2}%
    {\g@addto@macro\codep@conceptpending{%
       \codep@resolveconcept{#1}{#2}}}%
    {\codep@resolveconcept{#1}{#2}}%
}

%% @behavior B-CONC-SCOPE
% \codep@resolveconcept{srcatom}{conceptname}
%   Concept resolution callback.  Originally fed concept edges
%   into the backref linked list via \codep@appendbr; this was
%   removed (2026-04-11) because concept edges are NOT cross-
%   references — they should not appear in "Used in" lists.
%   The .aux records (\codep@concept, \codep@conceptref) and
%   .cdp records (\codep@cdp@def, \codep@cdp@use) remain
%   intact for the CLI layer.  The concept warning system
%   (\codep@conceptwarnscan) also remains.  This function is
%   now a silent no-op; it is kept so that stale .aux files
%   containing \codep@conceptref records (which trigger
%   \codep@resolveconcept via the pending list) do not error.
\def\codep@resolveconcept#1#2{}

% Swap the providecommand no-ops for the active callbacks
% at begindocument/before, before the .aux read.
%@effect state-only
\codep@target@install{AddToHook}{begindocument/before}{state-only}{%
  \codep@activation@let@install{\codep@concept}{\codep@concept@active}%
  \codep@activation@let@install{\codep@conceptref}{\codep@conceptref@active}%
}

% Flush the backref queue AFTER aux has been read.  The aux
% read happens during the kernel's \document macro before any
% \AtBeginDocument hook fires, so begindocument/end is safe.
\codep@target@install{AddToHook}{begindocument/end}{state-only}{%
  \codep@flushbrqueue
}

% Flush the concept pending list AFTER the backref queue
% flush.  Deferred \codep@resolveconcept calls expand here;
% the concept map is now complete from the full aux read.
\codep@target@install{AddToHook}{begindocument/end}{state-only}{%
  \codep@conceptpending
  \global\let\codep@conceptpending\@empty
}

% External ordering: run before hyperref wraps \@setref a
% second time in its \AtBeginDocument-equivalent hooks.
\DeclareHookRule{begindocument/before}%
  {codependent/backref/install}{before}{hyperref}

% Internal dependency: sbl open sees the backref install.
\DeclareHookRule{begindocument/before}{codependent/cdp/open}%
                {after}{codependent/backref/install}

% Concept install fires AFTER backref install (needs
% \codep@recordbr to be in place).
\DeclareHookRule{begindocument/before}%
  {codependent/concept/install}{after}{codependent/backref/install}

% Concept flush fires AFTER backref flush.  Concept edges
% use \codep@appendbr (direct node-list append, no queue),
% so ordering with the queue flush is not critical.  The
% "after" ordering ensures the backref queue processes first
% and concept edges are appended on top.
\DeclareHookRule{begindocument/end}%
  {codependent/concept/flush}{after}{codependent/backref/flush}

%% --- Section 8a.10: Front-edge ref-intent capture (SW5c commit 2) ---
%%
%% Wraps 12 user-level ref primitives at begindocument/end so that
%% \codep@atomref records are emitted on EVERY pass, including pass 1
%% when the target is still unresolved ("??").  SW5c commit 3 removes
%% the resolved-backend wrappers; these front-edge wrappers are now the
%% sole \codep@atomref emitters.  The track-two pending guard
%% (\codep@arw@pending@<tgt>, see \codep@writeatomref@tracktwo)
%% remains as defense-in-depth.
%%
%% INV-PASS1-EDGE-AUX-COMPLETE: all ref-uses that affect pass-2 backrefs
%% produce a \codep@atomref record on pass 1 regardless of resolution.
%%
%% §8 open questions resolved at implementation time:
%%   §8.1  \protected\def for all wrappers — survives \protected@edef.
%%   §8.2  Option (a) pending-append guard — see \codep@writeatomref@tracktwo.
%%   §8.3  \nameref survey: no fixture uses \nameref; keep 12-primitive list.
%%   §8.4  \cref@getlabel third-party survey: no exotic callers in integ
%%         fixtures; defer to commit 3 runtime warning.
%%   §8.5  pre-begindocument/end refs stay a documented waiver.

% \codep@splitlabels{csv}{macro}
%   Split comma-separated labels on top-level (unbraced) commas and
%   call \macro{label} for each label.  Brace-wrapped groups are
%   preserved as single labels: \cref{{a},b} -> \macro{a}, \macro{b}.
%   This matches cleveref for the well-formed case where each label is
%   individually brace-wrapped.  For malformed input such as
%   \cref{a,{b,c},d}, this splitter yields \macro{a}, \macro{b,c},
%   \macro{d} --- diverging from cleveref (which warns and treats a,
%   b, c as separate refs); see test-frontedge-cref-csv-divergence.lvt.
%   Empty items (e.g. from trailing commas) are silently skipped.
%% @utility
\def\codep@splitlabels#1#2{%
  \codep@sl@iter#1,\@nil{#2}%
}%
%% @utility
\def\codep@sl@iter#1,#2\@nil#3{%
  \def\codep@sl@item{#1}%
  \ifx\codep@sl@item\@empty\else%
    #3{#1}%
  \fi%
  \def\codep@sl@more{#2}%
  \ifx\codep@sl@more\@empty\else%
    \codep@sl@iter#2\@nil{#3}%
  \fi%
}%

% \codep@frontedge@emit{label}
%   Emit a front-edge atomref record for the current source atom.
%   Delegates to \codep@writeatomref which handles: replay-depth
%   guard, measuring-pass guard, equation track-one / track-two
%   dispatch (with the §2.7(a) pending guard), and dedup.
%% @behavior B-FRONTEDGE-CAPTURE
\def\codep@frontedge@emit#1{%
  \codep@writeatomref{#1}%
}%

% Front-edge single-label delegation helpers (no-star / star paths).
% #1 = saved original command, #2 = label.
%% @implements \codep@installfrontedgerefpatch
\def\codep@fe@single@nostar#1#2{%
  \codep@frontedge@emit{#2}%
  #1{#2}%
}%
%% @implements \codep@installfrontedgerefpatch
\def\codep@fe@single@star#1#2{%
  \codep@frontedge@emit{#2}%
  #1*{#2}%
}%

% Front-edge CSV-label delegation helpers (no-star / star paths).
% #1 = saved original command, #2 = comma-separated label string.
%% @implements \codep@installfrontedgerefpatch
\def\codep@fe@csv@nostar#1#2{%
  \codep@splitlabels{#2}{\codep@frontedge@emit}%
  #1{#2}%
}%
%% @implements \codep@installfrontedgerefpatch
\def\codep@fe@csv@star#1#2{%
  \codep@splitlabels{#2}{\codep@frontedge@emit}%
  #1*{#2}%
}%

% \codep@installfrontedgerefpatch
%   Install front-edge wrappers for the 12 user-level ref primitives.
%   Called at begindocument/end after nameref, hyperref, and cleveref
%   have installed their final definitions; our wrappers wrap whatever
%   is live at that point.  Every install is guarded by \ifcsdef so
%   absent commands (e.g. \cref when cleveref not loaded) are silently
%   skipped.  All wrappers are \protected so they survive \protected@edef
%   in moving args (captions, section titles, TOC entries).
%   SW5c commit 3 removes the resolved-backend wrappers; the pending
%   guard stays as belt-and-braces for multiline equation refs.
%% @behavior B-FRONTEDGE-CAPTURE
%% @behavior B-FRONTEDGE-DEDUP-EQ
%% @behavior B-EDGE-HYPERREF
%% Manual \hyperref[label]{...} calls are intentionally not wrapped
%% here. B-EDGE-HYPERREF documents that user-written \hyperref
%% produces a live link but does not participate in the codependent
%% backref graph; omitting \hyperref from the wrapped-primitive list
%% below is the carrier of that behavior.
%@effect inline-material
\def\codep@installfrontedgerefpatch{%
  %% ---- \ref and \ref* ----
  \ifcsdef{ref}{%
    \codep@target@install{command-wrap}{\ref}{inline-material}{%
      \protected\def\ref{%
        \@ifstar{\codep@fe@single@star\codep@orig@ref}%
                {\codep@fe@single@nostar\codep@orig@ref}%
      }%
    }%
  }{}%
  %% ---- \pageref and \pageref* ----
  \ifcsdef{pageref}{%
    \codep@target@install{command-wrap}{\pageref}{inline-material}{%
      \protected\def\pageref{%
        \@ifstar{\codep@fe@single@star\codep@orig@pageref}%
                {\codep@fe@single@nostar\codep@orig@pageref}%
      }%
    }%
  }{}%
  %% ---- \Ref and \Ref* (nameref) ----
  \ifcsdef{Ref}{%
    \codep@target@install{command-wrap}{\Ref}{inline-material}{%
      \protected\def\Ref{%
        \@ifstar{\codep@fe@single@star\codep@orig@Ref}%
                {\codep@fe@single@nostar\codep@orig@Ref}%
      }%
    }%
  }{}%
  %% ---- \cref and \cref* (cleveref) ----
  \ifcsdef{cref}{%
    \codep@target@install{command-wrap}{\cref}{inline-material}{%
      \protected\def\cref{%
        \@ifstar{\codep@fe@csv@star\codep@orig@cref}%
                {\codep@fe@csv@nostar\codep@orig@cref}%
      }%
    }%
  }{}%
  %% ---- \Cref and \Cref* (cleveref) ----
  \ifcsdef{Cref}{%
    \codep@target@install{command-wrap}{\Cref}{inline-material}{%
      \protected\def\Cref{%
        \@ifstar{\codep@fe@csv@star\codep@orig@Cref}%
                {\codep@fe@csv@nostar\codep@orig@Cref}%
      }%
    }%
  }{}%
  %% ---- \labelcref and \labelcref* (cleveref) ----
  \ifcsdef{labelcref}{%
    \codep@target@install{command-wrap}{\labelcref}{inline-material}{%
      \protected\def\labelcref{%
        \@ifstar{\codep@fe@csv@star\codep@orig@labelcref}%
                {\codep@fe@csv@nostar\codep@orig@labelcref}%
      }%
    }%
  }{}%
  %% ---- \autoref and \autoref* (hyperref) ----
  \ifcsdef{autoref}{%
    \codep@target@install{command-wrap}{\autoref}{inline-material}{%
      \protected\def\autoref{%
        \@ifstar{\codep@fe@single@star\codep@orig@autoref}%
                {\codep@fe@single@nostar\codep@orig@autoref}%
      }%
    }%
  }{}%
}%

% Install the front-edge wrappers at begindocument/end, AFTER the
% backref-flush hook so the aux-replay queue is processed first.
\codep@target@install{AddToHook}{begindocument/end}{state-only}{%
  \codep@installfrontedgerefpatch%
}%
\DeclareHookRule{begindocument/end}%
  {codependent/frontedge/install}{after}{codependent/backref/flush}%

%% ===================================================================
%% Section 8: Back-reference emission (rendering code in
%%            codependent-render.sty; tracking hooks remain here)
%% ===================================================================

%% @behavior B-NUM-PARA
% \codep@installparendhook
%   Install the para/end paragraph finalization hook.
%   Defensive flag clear: if a user invoked \codepbackrefs inside
%   the paragraph body, the per-atom \codep@manuallyemitted@<key>
%   flag was set; clear it here BEFORE the ctxpop drops the
%   paragraph atom from the ctx stack.  Empty-key branch is the
%   natural replay guard (\codep@getcurrentatomkey returns
%   \@empty during replay via \codep@getcurrentownerid).
%@effect state-only
\newcommand*{\codep@installparendhook}{%
  \codep@target@install{AddToHook}{para/end}{state-only}{%
    \ifbool{codep@tracked}{%
      \ifcodep@paragraphopen%
        \codep@getcurrentatomkey\codep@tmp@parakey%
        \ifx\codep@tmp@parakey\@empty\else%
          \codep@manuallyemitted@clear@key{\codep@tmp@parakey}%
        \fi%
        \codep@ctxpop{paragraph}%
        \global\codep@paragraphopenfalse%
      \fi%
    }{}%
  }%
}%

%% ===================================================================
%% Section 9a: Semantic sidecar (.cdp) writer
%% ===================================================================
%%
%% Write-only sidecar file for Layer 2 (semantic CLI).  The .sty
%% never reads .cdp — it is strictly one-way output.  Record format
%% is line-oriented: one \codep@cdp@* control sequence per line
%% with fixed-arity brace-delimited arguments (no kv blobs).
%%

%% @utility
% \codep@cdpwrite{text}
%   Guarded write to the .cdp stream.  No-op when the stream
%   is not open (e.g. \if@filesw is false).
%@effect immediate-write
\newcommand*{\codep@cdpwrite}[1]{%
  \ifbool{codep@cdpopen}{%
    \immediate\write\codep@cdpout{#1}%
  }{}%
}

%% @utility
% \codep@cdpwrite@atom{text}
%   Atom-scoped guard: drops the write when not inside a tracked
%   atom (\codep@currentatom is empty).  Every per-atom .cdp
%   record (label, tag, edge, use, …) routes through this guard;
%   record-specific emitters own their concrete arity and payload shape.
%@effect immediate-write
\newcommand*{\codep@cdpwrite@atom}[1]{%
  \codep@getcurrentatomdisplay\codep@tmp@cdpdisplay%
  \ifx\codep@tmp@cdpdisplay\@empty\else%
    \codep@cdpwrite{#1}%
  \fi%
}%

%% --- Section 9a open hook (begindocument/before) ---
%% Per REVIEW_C finding #5, the stream opens at begindocument/before
%% (before any \AtBeginDocument hook), so atoms emitted from user
%% hooks are never silently dropped.
%%
%% The header-record writes are factored into \codep@cdp@writeheader
%% so the BCDP-VERSION / BCDP-SOURCE invariants have honest carrier
%% macros tagged in this file (per docs/CONVENTIONS.md "every
%% @behavior tag must reference a real .sty macro").
%% @behavior BCDP-VERSION
%% @behavior BCDP-SOURCE
%@effect immediate-write
\def\codep@cdp@writeheader{%
  \immediate\write\codep@cdpout{%
    \string\codep@cdp@version{2}}%
  \immediate\write\codep@cdpout{%
    \string\codep@cdp@source{\jobname.tex}}%
}
\codep@target@install{AddToHook}{begindocument/before}{immediate-write}{%
  \if@filesw
    \newwrite\codep@cdpout
    \immediate\openout\codep@cdpout=\jobname.cdp\relax
    \global\booltrue{codep@cdpopen}%
    \codep@cdp@writeheader%
  \fi
}

%% --- Section 9a close hook: CDP sentinel drain ---
%% Write the \codep@cdp@end{OK} sentinel and close the stream.
%% Per REVIEW_C finding #7, the sentinel's presence is the CLI's
%% test for "complete file".  P04: invoked from
%% \codep@enddoc@orchestrator's drain@sentinel slot (must be LAST
%% of the drain slots since closing the stream drops later writes).
%% @behavior BCDP-SENTINEL
\def\codep@enddoc@drain@sentinel{%
  \ifbool{codep@cdpopen}{%
    \immediate\write\codep@cdpout{%
      \string\codep@cdp@end{OK}}%
    \immediate\closeout\codep@cdpout%
    \global\boolfalse{codep@cdpopen}%
  }{}%
}

%% --- Section 9a label wrap (cleveref-aware) ---
%% Installed at begindocument/before so we capture \label BEFORE
%% cleveref's \AtBeginDocument wrapper installs around us (see
%% docs/DESIGN.md §9a "Label wrap" double-wrap explanation).
%@effect immediate-write
\codep@target@install{AddToHook}{begindocument/before}{immediate-write}{%
  \codep@target@install{command-wrap}{\label}{immediate-write}{%
    \@ifpackageloaded{cleveref}{%
      %% cleveref path: \label[type]{key}, optional arg.
      \def\label{%
        \@ifnextchar[%]
          \codep@cdp@label@withopt
          \codep@cdp@label@noopt
      }%
    }{%
      %% No cleveref: \label{key} only.
      \def\label#1{%
        \codep@getcurrentatomdisplay\codep@tmp@labeldisplay%
        \ifx\codep@tmp@labeldisplay\@empty\else%
          \codep@cdpwrite@atom{%
            \string\codep@cdp@label
              {\codep@tmp@labeldisplay}{#1}}%
        \fi%
        \codep@recordlabelowner{#1}%
        \codep@label@samerun{#1}%
        \codep@orig@label{#1}%
      }%
    }%
  }%
}
%% @behavior B-PASS-ONE
% \codep@label@samerun{label}
%   Replay label-derived same-run anchor hydration from \label-time state.
\def\codep@label@samerun#1{%
  \codep@ifcrefkey{#1}{}{%
    \codep@ifdatakey{#1}{}{%
      \edef\codep@tmp@labelkey{#1}%
      \in@{thmt@@}{\codep@tmp@labelkey}%
      \ifin@\else%
        \csxdef{codep@lblnum@#1}{\@currentlabel}%
        \@ifpackageloaded{hyperref}{%
          \ifx\@currentHref\@empty\else%
            \ifcsundef{codep@ltype@#1}{%
              \let\codep@tmp@labeltype\@empty%
            }{%
              \edef\codep@tmp@labeltype{\csuse{codep@ltype@#1}}%
            }%
            \codep@writeanchoreff{#1}{\codep@tmp@labeltype}%
              {\@currentlabel}{\@currentHref}%
          \fi%
        }{}%
      \fi%
    }%
  }%
}%
%% @behavior B-PASS-ONE
\def\codep@cdp@label@withopt[#1]#2{%
  \codep@getcurrentatomdisplay\codep@tmp@labeldisplay%
  \ifx\codep@tmp@labeldisplay\@empty\else%
    \codep@cdpwrite@atom{%
      \string\codep@cdp@label%
        {\codep@tmp@labeldisplay}{#2}}%
  \fi%
  \codep@recordlabelowner{#2}%
  \codep@label@samerun{#2}%
  \codep@orig@label[#1]{#2}%
}%
%% @behavior B-PASS-ONE
\def\codep@cdp@label@noopt#1{%
  \codep@getcurrentatomdisplay\codep@tmp@labeldisplay%
  \ifx\codep@tmp@labeldisplay\@empty\else%
    \codep@cdpwrite@atom{%
      \string\codep@cdp@label%
        {\codep@tmp@labeldisplay}{#1}}%
  \fi%
  \codep@recordlabelowner{#1}%
  \codep@label@samerun{#1}%
  \codep@orig@label{#1}%
}%

%% @behavior B-PASS-ONE
% \codep@writelbltype{label}
%   Write the current atom type prefix to .aux for this label.
%   Priority order:
%   1. Standalone equation (\codep@eq@lbltype@pending non-empty):
%      amsmath defers \label to after the environment group closes, so
%      codep@inequation is already false and \codep@currentatom may
%      hold the preceding paragraph atom.  The globally-saved pending
%      type wins over any ambient paragraph context — equations own
%      their own labels.  Clear the register after use.
%   2. Inside a tracked theorem/proof atom (\codep@currentatom non-empty):
%      write \codep@currenttype (set by the theorem hook).
%   3. Otherwise: no-op (no owning atom).
\def\codep@writelbltype#1{%
  \codep@recordlabelowner{#1}%
}%

%% --- Section 9a concept-tracking helpers ---
%% Supporting macros for \codepnewcommand / \codepNewDocumentCommand.
%% The public API lives in Section 10; the emit helpers live here
%% because they write to both .cdp and .aux.

%% @utility
% \codep@cdpwrite@deferred{text}
%   Accumulate a deferred .cdp write for preamble-time emission.
%   Records queued here are flushed once the .cdp stream opens.
%   Used for \codep@cdp@cmddef records whose declarations occur
%   in the preamble before the stream is available.
%   IMPORTANT: the argument must already be fully expanded (no
%   transient macros like \codep@tmp@name) because \g@addto@macro
%   does not expand its argument.  Callers use \edef to pre-build
%   the record string.
%@effect deferred-write
\newcommand*{\codep@cdpwrite@deferred}[1]{%
  \ifbool{codep@cdpopen}{%
    % Stream already open (late declaration): write immediately.
    \codep@cdpwrite{#1}%
  }{%
    \g@addto@macro\codep@cdp@deferred{%
      \codep@cdpwrite{#1}}%
  }%
}

% Flush deferred sbl writes after the stream opens.
\codep@target@install{AddToHook}{begindocument/before}{state-only}{%
  \codep@cdp@deferred
  \global\let\codep@cdp@deferred\@empty
}
% Must run AFTER the sbl open hook.
\DeclareHookRule{begindocument/before}{codependent/cdp/cmddef}%
                {after}{codependent/cdp/open}

%% @behavior B-CONC-DEFSITE
%% @behavior B-CONC-DUPDEF
%% @behavior B-CONC-OUTSIDE
%% @behavior B-EDGE-CONC-OUTSIDE
% \codep@emit@def{name}
%   Star-branch handler: fires when \cmd* is used (defining site).
%   Records the current atom as the defining site for the named
%   concept.  Emits both .aux and .cdp records.  Per J2: empty-
%   currentatom short-circuit fires BEFORE the duplicate-def check.
%   name -- bare command name (e.g. "Hom")
\newcommand*{\codep@emit@def}[1]{%
  \codep@getcurrentatomdisplay\codep@tmp@conceptatom%
  \ifx\codep@tmp@conceptatom\@empty%
    % No atom context (footnote, caption, orphan): silent no-op.
  \else%
    \ifcsundef{codep@concept@#1}%
      {\csxdef{codep@concept@#1}%
         {\codep@tmp@conceptatom}%
       \if@filesw%
         \immediate\write\@auxout{%
           \string\codep@concept{#1}{\codep@tmp@conceptatom}}%
       \fi%
       \codep@cdpwrite@atom{%
         \string\codep@cdp@def{\codep@tmp@conceptatom}{#1}}%
      }%
      {\PackageError{codependent}%
        {\string\\#1* defined at atoms\space%
         \csuse{codep@concept@#1}\space and\space%
         \codep@tmp@conceptatom}%
        {Exactly one definition site is permitted per\space%
         concept.  Use \string\\#1\space (without star)\space%
         at the non-definitional site.}%
      }%
  \fi}%

%% @behavior B-CONC-EDGES
%% @behavior B-CONC-USEDIN
%% @behavior B-CONC-OUTSIDE
%% @behavior B-EDGE-CONC-OUTSIDE
% \codep@emit@use{name}
%   Non-star-branch handler: fires when \cmd is used (use site).
%   Emits both .aux and .cdp records under the current atom guard.
%   Registers the concept name for the missing-def-site scan at
%   \AtEndDocument (first-use only, guarded by conceptused csname).
%   name -- bare command name (e.g. "Hom")
\newcommand*{\codep@emit@use}[1]{%
  \codep@getcurrentatomdisplay\codep@tmp@conceptatom%
  \ifx\codep@tmp@conceptatom\@empty\else%
    % Register concept name for end-document missing-def scan.
    \ifcsundef{codep@conceptused@#1}{%
      \csgdef{codep@conceptused@#1}{1}%
      \g@addto@macro\codep@conceptnames{\do{#1}}%
    }{}%
    \if@filesw%
      \immediate\write\@auxout{%
        \string\codep@conceptref{\codep@tmp@conceptatom}{#1}}%
    \fi%
    \codep@cdpwrite@atom{%
      \string\codep@cdp@use{\codep@tmp@conceptatom}{#1}}%
  \fi}%

%% --- Section 9a.9: Concept missing-def-site scan ---
%% At \AtEndDocument, walk the concept name list and check each
%% concept for a matching def site.  Concepts with uses but no
%% def site trigger a warning (or info per conceptwarnings option).

%% @behavior B-CONC-NODEF
% \codep@conceptwarnscan
%   Walk \codep@conceptnames via \do.  For each concept name,
%   check if codep@conceptdef@<name> is defined.  If not, the
%   concept has uses but no \cmd* def-site marker; warn.
\def\codep@conceptwarnscan{%
  \def\do##1{%
    \ifcsundef{codep@conceptdef@##1}{%
      \ifbool{codep@conceptwarnings}{%
        \PackageWarning{codependent}{%
          \expandafter\string\csname ##1\endcsname\space%
          used but no starred definition site found;\MessageBreak%
          backrefs for this concept are disabled}%
      }{%
        \PackageInfo{codependent}{%
          \expandafter\string\csname ##1\endcsname\space%
          used but no starred definition site found%
          (conceptwarnings=off)}%
      }%
    }{}%
  }%
  \codep@conceptnames%
}

%% --- Section 9a.10: Shared wrapper-pipeline helper ---

%% @implements \codepnewcommand
% \codep@definetrackedcmd{name}{cmd}{kind}{key2}{val2}
%   Common pipeline shared by \codepnewcommand and
%   \codepNewDocumentCommand.  The declaration step (step 1) is
%   handled by the caller before invoking this helper.
%   name -- bare command name string (e.g. "Hom")
%   cmd  -- the command token (e.g. \Hom), already declared by caller
%   kind -- kind string for the .cdp cmddef record
%   key2 -- second .cdp attribute key (arity / argspec)
%   val2 -- second .cdp attribute value (pre-expanded by caller)
%
%   Steps performed:
%   2. Save original body to codep@body@<name>.
%   3. Define star/nostar dispatch helpers codep@star@<name> and
%      codep@nostar@<name> via \edef.
%   4. Redefine \cmd as a \protected\edef \@ifstar dispatcher.
%   5. Emit three deferred .cdp cmddef records: kind, key2/val2, src.
%@effect deferred-write
\def\codep@definetrackedcmd#1#2#3#4#5{%
  % 2-4. Save the original definition and install star dispatch.
  % 3. Define star/nostar dispatch targets.
  \expandafter\edef%
    \csname codep@star@#1\endcsname{%
      \noexpand\codep@emit@def{#1}%
      \expandafter\noexpand%
        \csname codep@body@#1\endcsname}%
  \expandafter\edef%
    \csname codep@nostar@#1\endcsname{%
      \noexpand\codep@emit@use{#1}%
      \expandafter\noexpand%
        \csname codep@body@#1\endcsname}%
  % 4. Redefine the command with star dispatch via \@ifstar.
  %    \protected\edef makes the wrapper robust so it survives
  %    expansion in moving arguments (\section titles, captions,
  %    .aux writes) without premature \@ifstar expansion.
  \codep@target@install{dynamic-command-wrap}{#2}{deferred-write}{%
    \noexpand\@ifstar%
      \expandafter\noexpand%
        \csname codep@star@#1\endcsname
      \expandafter\noexpand%
        \csname codep@nostar@#1\endcsname}%
  % 5. Emit global declaration records (deferred: the .cdp
  %    stream may not be open yet during the preamble).
  %    Records are pre-expanded via \edef so transient values
  %    (#1, \inputlineno) are captured eagerly.
  \edef\codep@tmp@rec{%
    \noexpand\codep@cdpwrite@deferred{%
      \string\codep@cdp@cmddef{#1}%
      {kind}{#3}}%
    \noexpand\codep@cdpwrite@deferred{%
      \string\codep@cdp@cmddef{#1}%
      {#4}{#5}}%
    \noexpand\codep@cdpwrite@deferred{%
      \string\codep@cdp@cmddef{#1}%
      {src}{\jobname.tex:\the\inputlineno:1}}%
  }%
  \codep@tmp@rec%
}

% P04: \codep@conceptwarnscan is called from
% \codep@enddoc@orchestrator's drain@warnscan slot (Section 9b).
% No direct \AtEndDocument registration here.

%% ===================================================================
%% Section 9b: Enddocument orchestrator (v11 R29 closure)
%% ===================================================================
%% A single \AddToHook{enddocument} registration that dispatches to
%% five named drain slots in a fixed order.  The three historical
%% \AtEndDocument sites (P03 refpending drain, CDP sentinel close,
%% conceptwarnscan) are consolidated here — each legacy body is
%% now an explicit drain slot, making the enddocument sequence
%% trivially inspectable and stable across future changes.
%%
%% Two-tier failure evaluator:
%%   \codep@enddoc@evaluator@pre runs BEFORE drains and may set
%%   \ifcodep@abortfinalize when it detects fatal pre-drain state
%%   (e.g. unsettled proof-binding slot).  When aborted, the
%%   drains are skipped and \codep@enddoc@halt fires \PackageError.
%%   \codep@enddoc@evaluator@post runs AFTER drains and emits
%%   \PackageWarning for residual non-fatal state (e.g. subsystem
%%   counters reporting incomplete work).
%%
%% v11 R29 closure: exactly ONE \AddToHook{enddocument} registration
%% in the entire codebase, enforced by lint_sty_structural.py (P04
%% A6 extension).

% Pre-drain evaluator — walks the subsystems list and flips
% \codep@abortfinalizetrue when any registered subsystem has
% failed==total && total>0 (i.e. EVERY tracked operation failed,
% so the drains would emit only stale records).  Wraps the walk
% in \begingroup so the \let\do... does not escape.
%% @behavior B-ERROR-ENDDOC
\def\codep@enddoc@evaluator@pre{%
  \begingroup%
    \let\do\codep@subsystem@check@fatal%
    \codep@subsystems@list%
  \endgroup%
}%

% Per-subsystem fatal check invoked by \do-walking
% \codep@subsystems@list.  Fatal when failed==total && total>0.
%% @utility
\def\codep@subsystem@check@fatal#1{%
  \ifnum\csname codep@subsys@#1@total\endcsname>0\relax%
    \ifnum\csname codep@subsys@#1@failed\endcsname=%
          \csname codep@subsys@#1@total\endcsname%
      \global\codep@abortfinalizetrue%
    \fi%
  \fi%
}%

% Halt body — fires when the pre-drain evaluator set
% \codep@abortfinalizetrue.  Drains are skipped to prevent
% emitting stale aux records; instead a PackageError names the
% condition and directs the user to preceding warnings for
% per-subsystem context.
%% @behavior B-ERROR-ENDDOC
\def\codep@enddoc@halt{%
  \PackageError{codependent}%
    {all operations in at least one subsystem failed; refusing to finalize output -- aux/cdp drains skipped to avoid stale records}%
    {Inspect preceding \string\PackageWarning\space lines for per-subsystem context.}%
}%

% Post-drain evaluator — warn-only; runs AFTER drains complete
% and emits one \PackageWarning per subsystem with
% 0<failed<total (partial-success residual).  Skipped entirely
% if the pre-drain evaluator aborted (already warned at halt
% time).  The failed==total case cannot occur here since it
% would have halted pre-drain.
%% @behavior B-WARN-ENDDOC
\def\codep@enddoc@evaluator@post{%
  \ifcodep@abortfinalize\else%
    \begingroup%
      \let\do\codep@subsystem@check@partial%
      \codep@subsystems@list%
    \endgroup%
  \fi%
}%

% Per-subsystem partial-success check invoked by \do-walking
% \codep@subsystems@list.  Emits \PackageWarning when the
% subsystem saw partial failures (some but not all operations).
%% @utility
\def\codep@subsystem@check@partial#1{%
  \ifnum\csname codep@subsys@#1@failed\endcsname>0\relax%
    \ifnum\csname codep@subsys@#1@failed\endcsname<%
          \csname codep@subsys@#1@total\endcsname%
      \PackageWarning{codependent}{%
        \the\csname codep@subsys@#1@failed\endcsname\space of\space%
        \the\csname codep@subsys@#1@total\endcsname\space#1%
        \space operations failed -- rendering with partial results}%
    \fi%
  \fi%
}%

% Drain slots — each is a thin wrapper delegating to the macro
% that historically ran inside an \AtEndDocument block.
%
% Order matters: sentinel MUST be last since closing the .cdp
% stream silently drops any later writes.  warnscan runs after
% the main drains so subsystem activity is visible to it.
%
%% @utility
\def\codep@enddoc@drain@p03{%
  \codep@refpending@drain%
}%
% drain@proofs — consume any still-pending proof-binding slot.
% If \codep@pendingproofbind is non-empty at enddoc the binding
% was declared but the proof environment that should have
% consumed it never appeared.  Record the failure and warn with
% the captured context; then clear the slot so an aborted run
% does not persist stale state (runtime-only, no aux impact).
%% @utility
\def\codep@enddoc@drain@proofs{%
  \ifx\codep@pendingproofbind\@empty\else%
    \codep@subsystem@recordfailed{proofof}%
    \PackageWarning{codependent}{proof-bind slot non-empty at \string\end{document} -- target '\codep@pendingproofbind@label' (declared at input line \codep@pendingproofbind@line) never resolved}%
    \global\let\codep@pendingproofbind\@empty%
    \global\let\codep@pendingproofbind@line\@empty%
    \global\let\codep@pendingproofbind@label\@empty%
  \fi%
}%
%% @behavior B-PASS-ONE
\def\codep@enddoc@drain@renderlist{%
  \ifnum\codep@replaydepth>0\relax%
  \else%
    \codep@renderlist@emit@all%
  \fi%
}%
%% @utility
\def\codep@enddoc@drain@warnscan{%
  \codep@conceptwarnscan%
}%
% \codep@enddoc@drain@sentinel is defined in Section 9a next to
% the CDP-stream machinery (must stay near \codep@cdpout).

% Orchestrator body — the single enddocument entry-point.
% Consolidates the three historical \AtEndDocument registrations
% into a fixed-order drain pipeline with a two-tier failure
% evaluator.  No behavior ID yet — this is infrastructure; the
% user-visible behaviors (error-on-fatal, warn-on-residual) are
% asserted via the evaluator bodies populated in commit 3.
%% @utility
%@effect deferred-write
\def\codep@enddoc@orchestrator{%
  \codep@enddoc@evaluator@pre%
  \ifcodep@abortfinalize%
    \codep@enddoc@halt%
  \else%
    \codep@enddoc@drain@p03%
    \codep@enddoc@drain@proofs%
    \codep@enddoc@drain@renderlist%
    \codep@enddoc@drain@warnscan%
    \codep@enddoc@drain@sentinel%
  \fi%
  \codep@enddoc@evaluator@post%
}%

% Single registration — enforced by lint_sty_structural.py.







\AddToHook{enddocument}{\codep@enddoc@orchestrator}

%% W05-P02 appendix-display override helpers (kept after enddoc hook so
%% install-discipline exact-line exceptions remain stable).
% \codep@appendixdisplay@store
%   Store the current pgfkeys appendix label override by theorem environment.
%% @utility
\def\codep@appendixdisplay@store{%
  \edef\codep@tmp@adkey{\pgfkeyscurrentname}%
  \edef\codep@tmp@adval{%
    \unexpanded\expandafter{\pgfkeyscurrentvalue}}%
  \expandafter\ifblank\expandafter{\codep@tmp@adval}{%
    \PackageError{codependent}{%
      empty appendix-display override for env '\codep@tmp@adkey'}{%
      Give appendix-display a non-empty literal label, or remove the key.}%
  }{%
    \global\cslet{codep@appendixdisplay@\codep@tmp@adkey}\codep@tmp@adval%
  }%
}%

\pgfkeys{%
  /codep/appendix-display/.cd,%
  .unknown/.code={\codep@appendixdisplay@store},%
}%

%% W05-P02 print-kind display-name helpers (kept after enddoc hook so
%% install-discipline exact-line exception remains stable).
% \codep@envtrack@printkind@store{env}{display-macro}
%   Store a declared theorem display name as a token-safe print-kind cache.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@printkind@store}[2]{%
  \csxdef{codep@envtrack@cfg@#1@print-kind}{%
    \unexpanded\expandafter{#2}}%
}

% \codep@envtrack@printkind@read{env}{macro}
%   Return the cached static display name, or env-name for generic envs.
%% @implements \codep@theorem@printkind@get
%@effect state-only
\newcommand*{\codep@envtrack@printkind@read}[2]{%
  \expandafter\let\expandafter#2%
    \csname codep@envtrack@cfg@#1@print-kind\endcsname%
  \ifx#2\relax\def#2{#1}\fi%
}

% \codep@envtrack@printkind@scan <tokens>\@thm{style}{ctr}{name}...
%   Scanner for amsthm-family and ntheorem declaration macros.
%% @implements \codeptrack
%@effect state-only
\long\def\codep@envtrack@printkind@scan#1\@thm#2#3#4#5\codep@stop{%
  \def\codep@tmp@printkind{#4}%
}

% \codep@envtrack@printkind@extract@target{target-cs}{fallback}
%   Expand one declaration macro body and extract the embedded \@thm name.
%% @implements \codeptrack
%@effect state-only
\long\def\codep@envtrack@printkind@extract@target#1#2{%
  \def\codep@tmp@printkind{#2}%
  \expandafter\codep@envtrack@printkind@scan#1\@thm{}{}{#2}\codep@stop%
}

% \codep@envtrack@printkind@resolve@static{env}
%   Resolve a static amsthm/thmtools/ntheorem display-name source.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@printkind@resolve@static}[1]{%
  \def\codep@tmp@printkind{#1}%
  \ifcsundef{mkheader@#1}{%
    \ifcsundef{thmt@original@#1}{%
      \ifcsundef{#1}{}{%
        \expandafter\codep@envtrack@printkind@extract@target%
          \csname #1\endcsname{#1}%
      }%
    }{%
      \expandafter\codep@envtrack@printkind@extract@target%
        \csname thmt@original@#1\endcsname{#1}%
    }%
  }{%
    \expandafter\codep@envtrack@printkind@extract@target%
      \csname mkheader@#1\endcsname{#1}%
  }%
  \codep@envtrack@printkind@store{#1}{\codep@tmp@printkind}%
}

% \codep@envtrack@printkind@resolve{env}
%   Route print-kind source selection through the backend descriptor.
%% @implements \codeptrack
%@effect state-only
\newcommand*{\codep@envtrack@printkind@resolve}[1]{%
  \codep@envtrack@ifkeytheoremsTF{#1}{%
    \codep@envtrack@config@write{#1}{print-kind-source}{keytheorems}%
  }{%
    \codep@envtrack@iftcolorboxTF{#1}{%
      \codep@envtrack@config@write{#1}{print-kind-source}{tcolorbox}%
    }{%
      \codep@envtrack@config@write{#1}{print-kind-source}{static}%
      \codep@envtrack@printkind@resolve@static{#1}%
    }%
  }%
}

% \codep@theorem@printkind@get{env}{macro}
%   Resolve the theorem rail's user-facing printable kind label.
%% @behavior B-PRINTKIND-DISPLAY-NAME
%@effect state-only
\def\codep@theorem@printkind@get#1#2{%
  \codep@envtrack@config@read{#1}{quirks-key}{\codep@tmp@quirks}%
  \ifx\codep@tmp@quirks\codep@quirks@tcolorboxtheorem%
    \codep@tcb@printkind@get{#1}{#2}%
  \else\ifx\codep@tmp@quirks\codep@quirks@keytheorems%
    \codep@keythms@printkind@get{#1}{#2}%
  \else%
    \codep@envtrack@printkind@read{#1}{#2}%
  \fi\fi%
}

% tcolorbox print-kind capture state.
%% @utility
\let\codep@tcb@printkind\@empty
%% @utility
\newif\ifcodep@tcb@titlefound
%% @utility
\def\codep@tcb@titlefallbackmarker{\codep@tcb@titlefallbackmarker}%
%% @utility
\def\codep@tcb@titlefallbacktail{\codep@tcb@titlefallbackmarker}%

% \codep@tcb@printkind@scan <tokens>\__tcobox_theo_title:nnn{name}{n}{t}
%   Scanner for tcolorbox's theorem title token list.
%% @implements \codep@theorem@printkind@get
%@effect state-only
\ExplSyntaxOn
\long\def\codep@tcb@printkind@scan#1\__tcobox_theo_title:nnn#2#3#4#5\codep@stop{%
  \def\codep@tmp@printkind{#2}%
  \def\codep@tmp@tail{#5}%
  \ifx\codep@tmp@tail\codep@tcb@titlefallbacktail%
    \global\codep@tcb@titlefoundfalse%
  \else%
    \global\codep@tcb@titlefoundtrue%
  \fi%
}
\ExplSyntaxOff

% \codep@tcb@captureprintkind{env}
%   Capture tcolorbox's parsed theorem display name after options are read.
%% @implements \codep@hooktheorem
%@effect state-only
\def\codep@tcb@captureprintkind#1{%
  \global\codep@tcb@titlefoundfalse%
  \def\codep@tmp@printkind{#1}%
  \ifcsundef{kvtcb@title}{%
    \PackageWarning{codependent}{%
      tcolorbox theorem adapter could not find \string\kvtcb@title;%
      \space print-kind display-name capture fell back to env name}%
  }{%
    \expandafter\codep@tcb@printkind@scan\kvtcb@title%
      \csname __tcobox_theo_title:nnn\endcsname{#1}{}{}%
      \codep@tcb@titlefallbackmarker\codep@stop%
    \ifcodep@tcb@titlefound\else%
      \PackageWarning{codependent}{%
        tcolorbox theorem adapter could not find the theorem title%
        \space payload; print-kind display-name capture fell back to env name}%
    \fi%
  }%
  \xdef\codep@tcb@printkind{\unexpanded\expandafter{\codep@tmp@printkind}}%
}%

% \codep@tcb@printkind@get{env}{macro}
%   Return the current tcolorbox theorem display name captured after options.
%% @implements \codep@theorem@printkind@get
%@effect state-only
\def\codep@tcb@printkind@get#1#2{%
  \ifx\codep@tcb@printkind\@empty%
    \def#2{#1}%
  \else%
    \let#2\codep@tcb@printkind%
  \fi%
}

% \codep@keythms@printkind@get{env}{macro}
%   Look up keytheorems' declaration-time printable theorem name property.
%% @implements \codep@theorem@printkind@get
%@effect state-only
\ExplSyntaxOn
\def\codep@keythms@printkind@get#1#2{%
  \def#2{#1}%
  \cs_if_exist:NT \g__keythms_thmnames_prop%
    {%
      \prop_get:NnNTF \g__keythms_thmnames_prop {#1} \l_tmpa_tl%
        { \tl_set_eq:NN #2 \l_tmpa_tl }%
        { }%
    }%
}
\ExplSyntaxOff

% \codep@entitymeta@capture@active{key}{kind}{display}{print-kind}{parent}
%   Same-run entitymeta table populate with token-safe print-kind capture.
%% @behavior B-PRINTKIND-DISPLAY-NAME
%@effect state-only
\def\codep@entitymeta@capture@active#1#2#3#4#5{%
  \csxdef{codep@entity@#1@kind}{#2}%
  \csxdef{codep@entity@#1@display}{#3}%
  \csxdef{codep@entity@#1@print}{%
    \unexpanded\expandafter{#4}}%
  \csxdef{codep@entity@#1@parent}{#5}}


%% ===================================================================
%% Section 10: User-facing API
%% ===================================================================

%% @implements \codeptrack
% \codep@extractfirst  env1,env2,...\@nil
%   Extract the first comma-separated element into \codep@basecounter.
%@effect state-only
\def\codep@extractfirst#1,#2\@nil{\def\codep@basecounter{#1}}

% \codeptrack{env1,env2,...}
%   Post-hoc alias base counter to atom counter and install all
%   hooks.  Must be called AFTER all \newtheorem declarations.
%   env1, env2, ... -- comma-separated environment names to track.
%   The first env name is auto-detected as the base counter name.
%% @behavior B-COMPAT-THMTOOLS-CONTINUED
%% @behavior B-EDGE-TRACK-ORDER
%% @behavior B-EDGE-TRACK-TWICE
% Generic env-hook surface: covers thmtools[continued] via generic hooks;
% no per-package shim.
%@effect state-only
\newcommand*{\codeptrack}[1]{%
  % Guard against double invocation (newcounter{atom} would crash).
  \ifbool{codep@tracked}{%
    \PackageError{codependent}%
      {\string\codeptrack\space called twice}%
      {Call \string\codeptrack\space only once, after all%
       theorem declarations.}%
  }{}%
  \booltrue{codep@tracked}%
  % Auto-detect the base counter from the first environment name.
  \codep@extractfirst#1,\@nil%
  \codep@envtrack@resolvecounter{\codep@basecounter}{\codep@tmp@counter}%
  \ifx\codep@tmp@counter\@empty%
    \codep@envtrack@ifxparseTF{\codep@basecounter}{}{%
      \PackageError{codependent}%
        {Counter '\codep@basecounter' undefined -- %
         \string\codeptrack\space called before%
         \string\newtheorem}%
        {Declare all theorem environments with%
         \string\newtheorem\space before calling%
         \string\codeptrack.}%
    }%
  \else%
    \let\codep@basecounter\codep@tmp@counter%
  \fi%
  \codep@setupcounter%
  % Hook each listed environment and its starred variant.
  % Note: \expandafter ensures the env name is fully expanded
  % before \codep@hooktheorem captures it in \AddToHook
  % bodies; without this, a stale \codep@tmp@envname reference would
  % resolve to the wrong name at hook-fire time.
  \@for\codep@tmp@envname:=#1\do{%
    \ifx\codep@tmp@envname\@empty\else
      % Re-alias this env's counter to \c@atom.  When thmtools
      % declares an env with sibling=<base>, it \let-aliases
      % \c@<env> to \c@<base> at declaration time.  But
      % \codep@setupcounter later replaces \c@<base> with
      % \c@atom; the sibling counters still point to the old
      % register.  This re-let ensures every tracked env's
      % counter is \c@atom, regardless of declaration order.
      \codep@envtrack@resolvecounter{\codep@tmp@envname}{\codep@tmp@counter}%
      \ifx\codep@tmp@counter\@empty\else%
        \codep@counter@alias@install{\codep@tmp@counter}{atom}%
        % Also aliases the resolved display macro \the<counter> to \theatom.
        % When thmtools declares an env with sibling=<base>, it
        % snapshots \the<base> at declaration time.  If codependent
        % later rewires \the<base> to \theatom, the sibling's
        % display macro still has the old format.  tcolorbox theorem
        % envs resolve to their internal tcb@cnt@<env> counter here.
      \fi%
      \codep@envtrack@resolve{\codep@tmp@envname}\codep@envtrack@printkind@resolve{\codep@tmp@envname}%
      \expandafter\codep@envtrack@dispatch%
        \expandafter{\codep@tmp@envname}%
      % Auto-register starred variant (amsthm creates foo*).
      \edef\codep@starred{\codep@tmp@envname*}%
      \expandafter\ifcsundef\expandafter{%
        \codep@starred%
      }{}{%
        \codep@envtrack@ifnumberedresolverTF{\codep@starred}{%
          \codep@envtrack@resolve{\codep@starred}\codep@envtrack@printkind@resolve{\codep@starred}%
          \expandafter\codep@envtrack@dispatch%
            \expandafter{\codep@starred}%
        }{}%
      }%
    \fi
  }%
  \codep@thmwrap@install@eventually%
  \codep@ntheorem@thmwrap@install@eventually%
  \codep@hookproof%
  % Install suppression and paragraph hooks.
  \codep@installsuppress%
  \codep@suppresssectioning%
  % Defer section title capture to begindocument/end so that
  % hyperref's \addcontentsline redefinition has already run.
  \codep@target@install{AddToHook}{begindocument/end}{state-only}{%
    \codep@capturesectitle}%
  \codep@suppresscommands%
  \codep@installparahook%
  \codep@installparendhook%
}

%% @behavior BCDP-FLAT-RECORD
% \codeptag{kind}{value}
%   Emit a semantic tag record to the .cdp sidecar, scoped to the
%   current atom.  No visible typesetting effect.  Ignored outside
%   a tracked atom.
%   kind  -- tag category (e.g. uid, introduces, type)
%   value -- tag payload (free-form UTF-8)
\newcommand*{\codeptag}[2]{%
  \codep@getcurrentatomdisplay\codep@tmp@tagatom%
  \ifx\codep@tmp@tagatom\@empty\else%
    \codep@cdpwrite@atom{%
      \string\codep@cdp@tag%
      {\codep@tmp@tagatom}{#1}{#2}}%
  \fi%
}%

% \codepbackrefs
%   User-driven backref emission point.  Resolves the active source
%   atom's key, sets the per-atom
%   \codep@manuallyemitted@<key> flag (so the env-end auto-flush
%   skips a duplicate emission), and routes through the rendering
%   layer's manual-emit hook to refresh + flush the "Used in ..." line
%   at the call site.  Outside any tracked atom: emits a package
%   warning and produces no output.  Complete no-op during
%   restatable replay (replay guard wraps the entire body).
%
%   The flag is cleared at env-end / proof-afterend / para-end hook
%   sites (see \codep@manuallyemitted@end@outer@clear,
%   \codep@hookproof@afterend, \codep@installparendhook).
%% @behavior B-REND-INLINE
\newcommand*{\codepbackrefs}{%
  \ifnum\codep@replaydepth=0\relax%
    \codep@getcurrentatomkey\codep@tmp@manualkey%
    \ifx\codep@tmp@manualkey\@empty%
      \PackageWarning{codependent}{%
        \string\codepbackrefs\space called outside any tracked atom%
        \space--- no refs emitted}%
    \else%
      \csxdef{codep@manuallyemitted@\codep@tmp@manualkey}{1}%
      \codep@render@manual@emit{\codep@tmp@manualkey}%
    \fi%
  \fi%
}%

% \codepbackrefsof{label}
%   User-driven remote backref read.  Resolves a tracked atom label to
%   its canonical atom key and renders that atom's refreshed "Used in"
%   line at the call site.  Unlike \codepbackrefs, this does not mark
%   the resolved atom manually emitted; the target atom's own auto-emit
%   remains unchanged.  Unknown or non-tracked labels warn and no-op.
%% @behavior B-REND-BACKREFSOF
\newcommand*{\codepbackrefsof}[1]{%
  \begingroup%
    \def\codep@tmp@backrefsoflabel{#1}%
    \ifcsdef{codep@lblentity@\codep@tmp@backrefsoflabel}{%
      \edef\codep@tmp@backrefsofkey{%
        \csuse{codep@lblentity@\codep@tmp@backrefsoflabel}}%
    }{%
      \ifcsdef{codep@lblnum@\codep@tmp@backrefsoflabel}{%
        \ifcsdef{codep@ltype@\codep@tmp@backrefsoflabel}{%
          \edef\codep@tmp@backrefsofkey{%
            \csuse{codep@ltype@\codep@tmp@backrefsoflabel}%
            :\csuse{codep@lblnum@\codep@tmp@backrefsoflabel}}%
        }{%
          \let\codep@tmp@backrefsofkey\relax%
        }%
      }{%
        \let\codep@tmp@backrefsofkey\relax%
      }%
    }%
    \ifx\codep@tmp@backrefsofkey\relax%
      \PackageWarning{codependent}{%
        \string\codepbackrefsof: unknown label '#1' %
        (not a tracked atom label)}%
    \else%
      \codep@render@refresh{\codep@tmp@backrefsofkey}%
      \codep@render@flushbackref{\codep@tmp@backrefsofkey}%
    \fi%
  \endgroup%
}%

% \codepproofof{label}    — bind a separated proof to label
% \codepproofof*{label}   — same, preserving explicit proof-anchor mode
%   Associate a separated proof with its theorem.  Must be called
%   inside a \begin{proof}...\end{proof} environment.  Looks up
%   the label's atom number and sets the current atom to the
%   starred version (e.g., 2.1*), enabling correct backref
%   attribution.
%
%   The proof-begin anchor is emitted when the proof opens.  When
%   \codepproofof rebinds the proof key later in the body, the new
%   proof:N.M key is aliased through \codep@anchormap to that
%   existing proof-begin anchor, so proof backrefs still land near
%   the proof heading rather than on the statement or a later
%   in-proof anchor.  The starred form is retained as a
%   compatibility spelling for the same proof-local target path.
%
%   Lazy proof integration: if the proof was non-adjacent,
%   \codep@proof@standalone only set the deferred flag (no atom
%   created yet).  \codepproofof clears the deferred flag and
%   assigns the proof's identity to the target theorem — no
%   standalone atom is ever materialized.
%% @behavior B-PROOF-SEP
%% @behavior B-LINK-PROOFOF-STAR
\newcommand{\codepproofof}{%
  \@ifstar{\codep@proofof@star}{\codep@proofof@plain}}
%% @implements \codep@proofof@do
\def\codep@proofof@plain#1{\codep@proofof@do{#1}{}}
%% @behavior B-LINK-PROOFOF-STAR
\def\codep@proofof@star#1{\codep@proofof@do{#1}{anchor}}
%% @behavior B-PROOF-SEP
% \codep@proofof@do{label}{anchormode}
%   Entry dispatcher for \codepproofof.  Try resolution paths in
%   order:
%     1. Legacy \codep@lblnum@<label> (aux-round-trip value,
%        stable across passes once the label has been seen once).
%     2. Same-run in-memory \codep@lblentity@<label> ->
%        \codep@entity@<atom-key>@display (active as soon as the
%        referenced entity finishes, so backward refs and same-run
%        forward refs whose target has already closed resolve now).
%     3. Defer via \codep@defer@proofof when neither is available.
%        The deferred token sequence is drained at enddoc by
%        \codep@refpending@drain against the now-complete binding.
\def\codep@proofof@do#1#2{%
  \ifbool{codep@proofsnumbered}{%
    \codep@subsystem@recordtotal{proofof}%
    \ifx\codep@currentproofid\@empty\else%
      \codep@proofof@do@resolver{\codep@proofof@resolve@warn}{#1}{#2}%
    \fi%
  }{}%
}%

% \codep@proofof@do@resolver{resolver}{label}{anchormode}
%   Dispatch a proof-of binding through the requested resolver.
%% @utility
\def\codep@proofof@do@resolver#1#2#3{%
  \ifcsundef{codep@lblnum@#2}{%
    \ifcsundef{codep@lblentity@#2}{%
      \codep@defer@proofof{#1}{\codep@currentproofid}{#2}{#3}%
    }{%
      #1{\codep@currentproofid}{#2}{#3}%
    }%
  }{%
    #1{\codep@currentproofid}{#2}{#3}%
  }%
}%

% \codep@proofof@resolve{proofid}{label}{anchormode}
%   Perform the proof<->target binding once the label is resolvable.
%   Called directly from \codep@proofof@do when the label is known
%   at proofof-time; called indirectly at enddoc drain time via the
%   deferred token sequence stored by \codep@defer@proofof.
%
%   Explicit callers look up the display number via the same cascade
%   as \codep@proofof@do (lblnum first, then lblentity->entity@display).
%   Auto-detected proof headings use only lblentity->entity@display so
%   non-tracked labels such as sections no-op silently.  If still
%   unresolved at this point the label truly never existed; record
%   failure silently so callers can decide whether to warn.
%% @behavior B-PROOF-SEP
\def\codep@proofof@resolve#1#2#3{%
  \codep@proofof@resolve@inner{0}{#1}{#2}{#3}%
}%

% \codep@autoproofof@resolve{proofid}{label}{provisional-key}
%   Auto-detected proof-heading resolver entry.  The third argument
%   may carry an unresref:<N> key for a deferred forward-ref binding.
%% @implements \codep@proofof@resolve
\def\codep@autoproofof@resolve#1#2#3{%
  \codep@proofof@resolve@inner{1}{#1}{#2}{#3}%
}%

% \codep@proofof@resolve@inner{auto-flag}{proofid}{label}{mode-or-prov}
%   Shared proof-attribution resolver.  auto-flag=1 uses the tracked
%   lblentity gate and may migrate body refs from an unresref:<N> source.
%% @implements \codep@proofof@resolve
\def\codep@proofof@resolve@inner#1#2#3#4{%
  \global\codep@proofof@resolvedfalse%
  \let\codep@tmp@proofdisp\@empty%
  \def\codep@tmp@autoflag{#1}%
  \def\codep@tmp@one{1}%
  \ifx\codep@tmp@autoflag\codep@tmp@one%
    \ifcsundef{codep@lblentity@#3}{}{%
      \edef\codep@tmp@proofentity{\csuse{codep@lblentity@#3}}%
      \edef\codep@tmp@proofdispcs{%
        codep@entity@\codep@tmp@proofentity @display}%
      \ifcsundef{\codep@tmp@proofdispcs}{}{%
        \edef\codep@tmp@proofdisp{%
          \csuse{\codep@tmp@proofdispcs}}%
      }%
    }%
  \else%
    \ifcsundef{codep@lblnum@#3}{%
      \ifcsundef{codep@lblentity@#3}{}{%
        \edef\codep@tmp@proofentity{\csuse{codep@lblentity@#3}}%
        \edef\codep@tmp@proofdispcs{%
          codep@entity@\codep@tmp@proofentity @display}%
        \ifcsundef{\codep@tmp@proofdispcs}{}{%
          \edef\codep@tmp@proofdisp{%
            \csuse{\codep@tmp@proofdispcs}}%
        }%
      }%
    }{%
      \edef\codep@tmp@proofdisp{\csuse{codep@lblnum@#3}}%
    }%
  \fi%
  \ifx\codep@tmp@proofdisp\@empty\else%
    \global\codep@proofof@resolvedtrue%
    \codep@proof@identitykey{#2}{\codep@tmp@proofkey}%
    \codep@atomgetkey{#2}{\codep@tmp@oldproofkey}%
    \ifx\codep@tmp@autoflag\codep@tmp@one%
      \codep@ifunresrefkey{#4}{%
        \edef\codep@tmp@oldproofkey{#4}%
      }{}%
    \fi%
    \codep@proof@setidentity{#2}%
    \ifcsundef{codep@lblentity@#3}{%
      \edef\codep@tmp@proofparentval{theorem:\codep@tmp@proofdisp}%
    }{%
      \edef\codep@tmp@proofparentval{%
        \csuse{codep@lblentity@#3}}%
    }%
    \ifx\codep@tmp@autoflag\codep@tmp@one%
      \codep@proof@maybeheadingoverrideadjacent{#2}{%
        \codep@tmp@proofparentval}{\codep@tmp@proofdisp}%
    \fi%
    \codep@prooftargetmeta@append{\codep@tmp@proofkey}{%
      \codep@tmp@proofparentval}{\codep@tmp@proofdisp}{*}%
    \codep@proof@markparent{#2}{\codep@tmp@proofparentval}%
    \codep@atomsetkey{#2}{\codep@tmp@proofkey}%
    \codep@proof@writebeginpage{#2}{\codep@tmp@proofkey}%
    \ifx\codep@tmp@oldproofkey\@empty\else%
      \ifx\codep@tmp@oldproofkey\codep@tmp@proofkey\else%
        \ifx\codep@tmp@autoflag\codep@tmp@one%
          \codep@keymap@record{%
            \codep@tmp@oldproofkey}{\codep@tmp@proofkey}%
        \fi%
      \fi%
    \fi%
    \edef\codep@tmp@resolverproofid{#2}%
    \ifx\codep@tmp@resolverproofid\codep@currentproofid%
    \else%
      \codep@graph@getdisplay{\codep@tmp@proofkey}{%
        \codep@tmp@proofrenderdisp}%
      \codep@captureentitymeta{\codep@tmp@proofkey}{proof}%
        {\codep@tmp@proofrenderdisp}{proof}{\codep@tmp@proofparentval}%
      \if@filesw%
        \protected@write\@auxout{}{%
          \string\codep@entitymeta{\codep@tmp@proofkey}{proof}%
            {\codep@tmp@proofrenderdisp}{proof}{\codep@tmp@proofparentval}}%
      \fi%
    \fi%
    \global\codep@proofdisplaypendingfalse%
    \global\codep@autoproofof@eligiblefalse%
    \global\let\codep@pendingproofbind\@empty%
    \ifx\codep@tmp@autoflag\codep@tmp@one%
      \codep@proof@adjcandidate@drop{#2}%
    \fi%
    \if@filesw%
      \ifx\codep@tmp@autoflag\codep@tmp@one%
        \codep@ifunresrefkey{#4}{%
          \codep@unresref@flushrefs{#4}{\codep@tmp@proofkey}%
        }{}%
      \fi%
      \codep@subsystem@recordtotal{atomref}%
      \codep@dedupwrite{\codep@tmp@proofkey}{#3}%
    \fi%
    \codep@proof@bindbeginanchor{#2}{\codep@tmp@proofkey}%
    % SAFE-TO-REINVOKE, NOT IDEMPOTENT: joint-proof attribution
    % refreshes the same proof key after each per-label graph growth;
    % proof-end flush reads the final snapshot.
    \codep@render@refresh{\codep@tmp@proofkey}%
    \codep@proofof@attribcount@advance{#2}%
  \fi%
}%

% \codep@proofof@resolve@warn{proofid}{label}{anchormode}
%   Resolver wrapper used by explicit \codepproofof calls.
%% @behavior B-EDGE-BADLABEL
\def\codep@proofof@resolve@warn#1#2#3{%
  \codep@proofof@resolve{#1}{#2}{#3}%
  \ifcodep@proofof@resolved\else%
    \PackageWarning{codependent}{\string\codepproofof: unknown label\space%
      '#2'. The label may not exist or may not have been processed yet}%
  \fi%
}%

% \codepnewcommand{\cmd}[arity]{body}
%   Define a command with codependent concept tracking.  Mirrors
%   \newcommand exactly: \cmd with backslash, optional [arity]
%   (default 0), mandatory {body} using #1..#N.
%
%   At declaration time, emits three global .cdp records:
%     \codep@cdp@cmddef{name}{kind}{newcommand}
%     \codep@cdp@cmddef{name}{arity}{N}
%     \codep@cdp@cmddef{name}{src}{file:line:1}
%
%   At invocation time, the wrapped command answers both
%   \cmd (use site) and \cmd* (def site).  Both forms typeset
%   the same body; the star controls which emit helper fires.
%
%   \cmd  -- command to define (with backslash, e.g. \Hom)
%   arity -- optional integer 0..9 (default 0)
%   body  -- replacement text, uses #1..#N
%% @behavior B-CONC-EDGES
\NewDocumentCommand{\codepnewcommand}{m O{0} +m}{%
  % #1 = \cmd (with backslash), #2 = arity, #3 = body.
  \edef\codep@tmp@name{%
    \expandafter\@gobble\string#1}%
  % 1. Define the command via \newcommand (handles all #-
  %    numbering naturally).
  \newcommand#1[#2]{#3}%
  % 2-5. Shared pipeline: save body, build wrappers, emit .cdp.
  \codep@definetrackedcmd{\codep@tmp@name}{#1}%
    {newcommand}{arity}{\number#2}%
}
% Deprecated alias — old documents using \codepNewCommand still work.
\let\codepNewCommand\codepnewcommand

% \codepNewDocumentCommand{\cmd}{argspec}{body}
%   Define a command with codependent concept tracking, using xparse's
%   full argument specification.  Mirrors \NewDocumentCommand
%   exactly: \cmd with backslash, {argspec} string, {body}.
%
%   At declaration time, emits three global .cdp records:
%     \codep@cdp@cmddef{name}{kind}{NewDocumentCommand}
%     \codep@cdp@cmddef{name}{argspec}{<user-spec>}
%     \codep@cdp@cmddef{name}{src}{file:line:1}
%
%   At invocation time, the wrapped command prepends a codependent
%   star to the user's argspec.  \cmd* marks a def site; \cmd
%   marks a use site.  Both typeset the same body.  If the
%   user's argspec itself starts with "s", the user's star
%   requires a second "*" at call time (e.g. \cmd** for
%   codependent-def + user-star).
%
%   \cmd    -- command to define (with backslash)
%   argspec -- xparse argument specification string
%   body    -- replacement text, uses #1..#N per the spec
%% @behavior B-CONC-EDGES
\NewDocumentCommand{\codepNewDocumentCommand}{m m +m}{%
  % #1 = \cmd, #2 = argspec, #3 = body.
  \edef\codep@tmp@name{%
    \expandafter\@gobble\string#1}%
  % 1. Define the command via \NewDocumentCommand (handles
  %    all xparse arg types and #-numbering naturally).
  \NewDocumentCommand{#1}{#2}{#3}%
  % 2-5. Shared pipeline: save body, build wrappers, emit .cdp.
  \codep@definetrackedcmd{\codep@tmp@name}{#1}%
    {NewDocumentCommand}{argspec}{#2}%
}

%% @behavior B-EQ-TRACK1
% \codeptrackeq{envname}
%   Register a custom single-number equation environment (Track 1).
%@effect state-only
\newcommand*{\codeptrackeq}[1]{\codep@trackeqenv{#1}}
%% @behavior B-EQ-TRACK2
% \codeptrackalign{envname}
%   Register a custom multi-number equation environment (Track 2).
%@effect state-only
\newcommand*{\codeptrackalign}[1]{\codep@trackalignenv{#1}}

%% @behavior B-SUPP-EXTEND
% \codepsuppress{envname}
%   Register a user environment for paragraph-number suppression.
%   envname -- environment name to suppress
\newcommand*{\codepsuppress}[1]{%
  \codep@suppressenv{#1}%
}

%% @behavior B-SUPP-EXTEND
%% @behavior B-SUPP-CMDS
% \codepsuppresscmd{\command}
%   Register a user command for paragraph-number suppression.
%   \command -- command to patch
\newcommand*{\codepsuppresscmd}[1]{%
  \codep@suppresscmd{#1}%
}

% \codepappendix — fallback definition when rendering is not loaded.
%   The live implementation is in codependent-render.sty and
%   overrides this with \renewcommand.
%% @behavior B-REND-APPENDIX
\newcommand*{\codepappendix}{%
  \PackageWarning{codependent}{%
    \string\codepappendix\space requires the rendering layer%
    (codependent-render.sty), which is not loaded when%
    backrefs=none}%
}

%% ===================================================================
%% Section 11: Compatibility guards
%% ===================================================================

% Guard: require LaTeX2e kernel with hook management.
\ifcsundef{AddToHook}{%
  \PackageError{codependent}{%
    LaTeX kernel too old (need 2021+)}{%
    codependent requires \string\AddToHook\space
    (TeX Live 2021 or later).%
  }%
}{}

% Hyperref link wrapping for backref numbers.
% Receives a prefixed key (e.g. theorem:2.1, equation:3.1, proof:a7).
% Default (no rendering): bare pass-through.  Redefined by
% codependent-render.sty to format via \codep@displayfromkey
% and (with hyperref) wrap in \hyperlink.
%% @behavior B-LINK-CLICKABLE
\newcommand*{\codep@brhyper}[1]{#1}

% Hyperref detection: activate atom→anchor aux record WRITING.
% The reading side (\codep@anchormap) is activated in
% begindocument/before (§8a.7) so it is live BEFORE the aux read.
% The \codep@brhyper hyperlink rendering is handled by
% codependent-render.sty in its own \AtBeginDocument block.
\AtBeginDocument{%
  \@ifpackageloaded{hyperref}{%
    \renewcommand*{\codep@writeanchormap}[1]{%
      \csxdef{codep@anchor@#1}{\@currentHref}%
      \if@filesw%
        \protected@write\@auxout{}{%
          \string\codep@anchormap{#1}{\@currentHref}}%
      \fi}%
  }{}%
}

%% ===================================================================
%% Conditional rendering layer load
%% ===================================================================
%% When backrefs are enabled, load codependent-render.sty which
%% defines all rendering primitives and redefines the no-op hook
%% points to their live implementations.
\ifbool{codep@backrefs}{\RequirePackage{codependent-render}}{}

\endinput