GetItemStats: add weapon DPS and equip-spell stats

Weapon DPS (avg damage across the slots / swing time) is emitted under ITEM_MOD_DAMAGE_PER_SECOND_SHORT, matching 3.3.5's GetItemStats. Vanilla stores the "special" gear stats (crit, attack power, spell power/healing, hit, mp5, defense) as on-equip spells rather than stat slots, so decode each item's SpellTrigger == ON_EQUIP spells - and the random-suffix equip enchants - through the SPELL_AURA_* effects and fold them into the modern GetItemStats keys. Percent stats (crit/hit/defense) are reported as the raw vanilla percentage under the *_RATING key, since vanilla has no (level-dependent) rating conversion; e.g. Krol Blade's +1% crit is CRIT_MELEE_RATING = 1, not the 13 rating TBC/Era would show. Generic attack power subsumes its paired ranged-AP aura; rarer auras with no clean key (percent AP, per-weapon-line skill, procs) are skipped. Documents the full key set and its sources in docs/API.md.
Add C_Item.GetItemStats / GetItemStatDelta
2026-11-12 12:57:37 +00:00 · 2026-07-01 16:28:42 -05:00 · 2026-07-01 15:29:14 -05:00 · 2026-07-01 14:59:46 -05:00 · 2026-07-01 14:34:31 -05:00 · 2026-07-01 13:59:21 -05:00
265 changed files with 5221 additions and 1077 deletions
@@ -27,6 +27,7 @@ Util\EventUtil.lua
 Util\ItemUtil.lua
 Util\AddOnCompat.lua
 Util\FunctionUtil.lua
+Util\CacheUtil.lua
 Util\Pools.lua
 Util\FrameWatcher.lua
 Util\TimedCallback.lua
@@ -0,0 +1,88 @@
+-- On-demand, throttled cache warmer (/warmcache). A brute-force scan of the
+-- whole ID space floods the client's network buffers and panics in
+-- WDataStoreSmallBuffer ("not enough memory") — the engine can't hold that
+-- many pending queries. So this warms a *bounded* range, started/stopped
+-- manually, at a low fixed rate. Tune WARM_RATE / WARM_INTERVAL if needed,
+-- but keep it modest. Note: IDs the server doesn't know (gaps in the range)
+-- get no response, so their pending entries linger — warm ranges you expect
+-- to be mostly real, not arbitrary millions.
+--
+--   /warmcache item 1 40000     warm item IDs 1..40000
+--   /warmcache <type> <a> <b>   type = item | quest | creature | object | all
+--   /warmcache stop             abort an in-progress warm
+local WARM_RATE = 20      -- IDs queued per tick
+local WARM_INTERVAL = 0.2 -- seconds between ticks  (-> ~20 IDs/sec)
+
+local WARM_FN = {
+	item     = function(id) C_Item.RequestLoadItemDataByID(id) end,
+	quest    = function(id) C_QuestLog.RequestLoadQuestByID(id) end,
+	creature = function(id) C_CreatureInfo.RequestLoadCreatureByID(id) end,
+	object   = function(id) C_GameObjectInfo.RequestLoadGameObjectByID(id) end,
+	all      = function(id)
+					C_QuestLog.RequestLoadQuestByID(id)
+					C_Item.RequestLoadItemDataByID(id)
+					C_CreatureInfo.RequestLoadCreatureByID(id)
+					C_GameObjectInfo.RequestLoadGameObjectByID(id)
+			end,
+}
+
+local warm = { running = false, cancel = false }
+
+local function warm_msg(s)
+	DEFAULT_CHAT_FRAME:AddMessage("|cff66ccff[WarmCache]|r " .. s)
+end
+
+local function warm_step(fn, id, stop, lastMsg)
+	if warm.cancel then
+		warm.running = false
+		warm_msg("stopped at " .. (id - 1))
+		return
+	end
+	local n = 0
+	while n < WARM_RATE and id <= stop do
+		fn(id)
+		n = n + 1
+		id = id + 1
+	end
+	if id > stop then
+		warm.running = false
+		warm_msg("done (through " .. stop .. ")")
+	else
+		if (id - 1) - lastMsg >= 1000 then
+			warm_msg((id - 1) .. " / " .. stop .. " ...")
+			lastMsg = id - 1
+		end
+		C_Timer.After(WARM_INTERVAL, function() warm_step(fn, id, stop, lastMsg) end)
+	end
+end
+
+SLASH_WARMCACHE1 = "/warmcache"
+SlashCmdList["WARMCACHE"] = function(msg)
+	local args = {}
+	for tok in string.gmatch(msg or "", "%S+") do
+		table.insert(args, string.lower(tok))
+	end
+	local cmd = args[1]
+
+	if cmd == "stop" then
+		if warm.running then warm.cancel = true else warm_msg("not running") end
+		return
+	end
+	if warm.running then
+		warm_msg("already running - /warmcache stop first")
+		return
+	end
+
+	local fn = WARM_FN[cmd]
+	local a, b = tonumber(args[2]), tonumber(args[3])
+	if not fn or not a or not b or a < 1 or b < a then
+		warm_msg("usage: /warmcache item|quest|creature|object|all <startID> <stopID>")
+		warm_msg("       /warmcache stop")
+		return
+	end
+
+	warm.running, warm.cancel = true, false
+	warm_msg(string.format("warming %s %d..%d (~%d/sec, /warmcache stop to abort)",
+		cmd, a, b, math.floor(WARM_RATE / WARM_INTERVAL)))
+	warm_step(fn, a, b, a - 1)
+end
@@ -27,13 +27,12 @@ INVSLOT_BACK		= 15;
 INVSLOT_MAINHAND	= 16;
 INVSLOT_OFFHAND		= 17;
 INVSLOT_RANGED		= 18;
-INVSLOT_TABARD		= 19;
-INVSLOT_LAST_EQUIPPED = INVSLOT_TABARD;
+INVSLOT_TABARD		= 19; INVSLOT_LAST_EQUIPPED = INVSLOT_TABARD;

 INVSLOTS_EQUIPABLE_IN_COMBAT = {
-[INVSLOT_MAINHAND] = true,
-[INVSLOT_OFFHAND] = true,
-[INVSLOT_RANGED] = true,
+	[INVSLOT_MAINHAND] = true,
+	[INVSLOT_OFFHAND] = true,
+	[INVSLOT_RANGED] = true,
 }

 -- Item IDs
@@ -1,5 +1,4 @@
-local className = UnitClass('player')
-local classFile, classID = UnitClassBase('player')
+local className, classFile, classID = UnitClass('player'), UnitClassBase('player')

 PlayerUtil = PlayerUtil or {}

@@ -32,12 +31,8 @@ function PlayerUtil.GetCurrentSpeed()
    return GetUnitSpeed("player") / 7 * 100
 end

-local playerGuid
 function GetPlayerGuid()
-	if not playerGuid then
-		playerGuid = UnitGUID("player")
-	end
-	return playerGuid
+	return UnitGUID("player")
 end

 function IsPlayerGuid(guid)
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
@@ -26,6 +26,7 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
 | [Cursor](docs/API.md#cursor) | `GetCursorInfo` |
 | [Container](docs/API.md#container) | `C_Container.GetContainerItemCharges`, `C_Container.GetContainerItemDurability`, `C_Container.GetContainerItemID`, `C_Container.GetContainerItemRepairCost`, `C_Container.GetContainerNumFreeSlots`, `C_Container.GetItemCooldown`, `C_Container.IsContainerItemOpenable`, `C_Container.MoveItem`, `C_Container.PlayerHasHearthstone`, `C_Container.SwapItems`, `C_Container.UseHearthstone`, `GetItemCooldown` |
 | [Coroutine](docs/API.md#coroutine) | `coroutine.create`, `coroutine.resume`, `coroutine.yield`, `coroutine.status`, `coroutine.wrap` |
+| [Creature](docs/API.md#creature) | `C_CreatureInfo.GetCreatureID`, `C_CreatureInfo.GetCreatureInfoByID`, `C_CreatureInfo.RequestLoadCreatureByID` |
 | EncodingUtil | `C_EncodingUtil.CompressString`, `C_EncodingUtil.DecompressString`, `C_EncodingUtil.EncodeBase64`, `C_EncodingUtil.DecodeBase64`, `C_EncodingUtil.EncodeHex`, `C_EncodingUtil.DecodeHex`, `C_EncodingUtil.SerializeJSON`, `C_EncodingUtil.DeserializeJSON`, `C_EncodingUtil.SerializeCBOR`, `C_EncodingUtil.DeserializeCBOR` |
 | [EquipmentSet](docs/API.md#equipmentset) | `C_EquipmentSet.CanUseEquipmentSets`, `C_EquipmentSet.ClearIgnoredSlotsForSave`, `C_EquipmentSet.CreateEquipmentSet`, `C_EquipmentSet.DeleteEquipmentSet`, `C_EquipmentSet.EquipmentSetContainsLockedItems`, `C_EquipmentSet.GetEquipmentSetID`, `C_EquipmentSet.GetEquipmentSetIDs`, `C_EquipmentSet.GetEquipmentSetInfo`, `C_EquipmentSet.GetIgnoredSlots`, `C_EquipmentSet.GetItemIDs`, `C_EquipmentSet.GetItemLocations`, `C_EquipmentSet.GetNumEquipmentSets`, `C_EquipmentSet.IgnoreSlotForSave`, `C_EquipmentSet.IsSlotIgnoredForSave`, `C_EquipmentSet.ModifyEquipmentSet`, `C_EquipmentSet.SaveEquipmentSet`, `C_EquipmentSet.UnignoreSlotForSave`, `C_EquipmentSet.UseEquipmentSet` |
 | [Events](docs/API.md#events) | `C_EventUtils.IsEventValid` |
@@ -33,28 +34,29 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
 | [Faction](docs/API.md#faction) | `C_Reputation.GetFactionDataByIndex`, `C_Reputation.GetFactionStandings`, `C_Reputation.GetLastStandingChange`, `C_Reputation.GetWatchedFactionData`, `C_Reputation.SetWatchedFactionByID`, `GetFactionIDByIndex`, `GetFactionInfoByID`, `GetFactionParentID` |
 | [Focus](docs/API.md#focus) | `ClearFocus`, `FocusUnit` |
 | [FriendList](docs/API.md#friendlist) | `C_FriendList.IsWhoQueryPending`, `C_FriendList.SendWhoQueryByName` |
+| [GameObject](docs/API.md#gameobject) | `C_GameObjectInfo.GetGameObjectInfoByID`, `C_GameObjectInfo.RequestLoadGameObjectByID` |
 | [Gossip](docs/API.md#gossip) | `C_GossipInfo.CloseGossip`, `C_GossipInfo.GetActiveQuests`, `C_GossipInfo.GetAvailableQuests`, `C_GossipInfo.GetNumActiveQuests`, `C_GossipInfo.GetNumAvailableQuests`, `C_GossipInfo.GetNumOptions`, `C_GossipInfo.GetOptions`, `C_GossipInfo.GetText`, `C_GossipInfo.SelectActiveQuest`, `C_GossipInfo.SelectAvailableQuest`, `C_GossipInfo.SelectOption`, `C_GossipInfo.SelectOptionByIndex` |
 | [GameTooltip](docs/API.md#gametooltip) | `GameTooltip:GetGameObject`, `GameTooltip:GetItem`, `GameTooltip:GetOwner`, `GameTooltip:GetSpell`, `GameTooltip:GetUnitGUID`, `GameTooltip:HasGameObject`, `GameTooltip:HasItem`, `GameTooltip:HasSpell`, `GameTooltip:HasUnit`, `GameTooltip:SetEquipmentSet`, `GameTooltip:SetInventoryItemByID`, `GameTooltip:SetItemByGUID`, `GameTooltip:SetItemByID`, `GameTooltip:SetSpellByID`, `GameTooltip:SetTalentByID`, `GameTooltip:SetUnitAura` |
 | [Hooks](docs/API.md#hooks) | `hooksecurefunc` |
 | [Input](docs/API.md#input) | `IsLeftAltKeyDown`, `IsLeftControlKeyDown`, `IsLeftShiftKeyDown`, `IsModifierKeyDown`, `IsMouseButtonDown`, `IsRightAltKeyDown`, `IsRightControlKeyDown`, `IsRightShiftKeyDown` |
 | [Instance](docs/API.md#instance) | `GetInstanceInfo` |
-| [Item](docs/API.md#item) | `C_Item.DoesItemExist`, `C_Item.DoesItemExistByID`, `C_Item.EquipItemByName`, `C_Item.GetCurrentItemLevel`, `C_Item.GetDetailedItemLevelInfo`, `C_Item.GetEnchantInfo`, `C_Item.GetItemCount`, `C_Item.GetItemFamily`, `C_Item.GetItemGUID`, `C_Item.GetItemIcon`, `C_Item.GetItemIconByID`, `C_Item.GetItemID`, `C_Item.GetItemInfoInstant`, `C_Item.GetItemInventoryType`, `C_Item.GetItemInventoryTypeByID`, `C_Item.GetItemLink`, `C_Item.GetItemLocation`, `C_Item.GetItemMaxStackSize`, `C_Item.GetItemMaxStackSizeByID`, `C_Item.GetItemName`, `C_Item.GetItemNameByID`, `C_Item.GetItemQuality`, `C_Item.GetItemQualityByID`, `C_Item.GetItemSellPrice`, `C_Item.GetItemSellPriceByID`, `C_Item.GetItemSetID`, `C_Item.GetItemSetIDByID`, `C_Item.GetItemSetInfo`, `C_Item.GetItemSpell`, `C_Item.GetItemUniqueness`, `C_Item.GetItemUniquenessByID`, `C_Item.GetStackCount`, `C_Item.GetWeaponEnchantInfo`, `C_Item.IsBound`, `C_Item.IsEquippableItem`, `C_Item.IsEquippedItem`, `C_Item.IsItemDataCached`, `C_Item.IsItemDataCachedByID`, `C_Item.IsItemOpenable`, `C_Item.IsLocked`, `C_Item.LockItem`, `C_Item.LockItemByGUID`, `C_Item.UnlockAllItems`, `C_Item.UnlockItem`, `C_Item.RequestLoadItemData`, `C_Item.RequestLoadItemDataByID`, `C_Item.UseAtCursor`, `C_Item.UseAtUnit`, `C_Item.UseItemByName`, `GetAuctionItemID`, `GetAuctionSellItemID`, `GetAverageItemLevel`, `GetCraftReagentItemID`, `GetInboxItemID`, `GetInventoryItemDurability`, `GetInventoryItemID`, `GetInventoryItemsForSlot`, `GetInventoryItemRepairCost`, `GetItemIcon`, `GetLootRollItemID`, `GetLootSlotItemID`, `GetMerchantItemID`, `GetQuestItemID`, `GetQuestLogItemID`, `GetTradePlayerItemID`, `GetTradeSkillItemID`, `GetTradeSkillReagentItemID`, `GetTradeTargetItemID`, `OffhandHasWeapon` |
+| [Item](docs/API.md#item) | `C_Item.DoesItemExist`, `C_Item.DoesItemExistByID`, `C_Item.EquipItemByName`, `C_Item.GetCurrentItemLevel`, `C_Item.GetDetailedItemLevelInfo`, `C_Item.GetEnchantInfo`, `C_Item.GetItemCount`, `C_Item.GetItemFamily`, `C_Item.GetItemGUID`, `C_Item.GetItemIcon`, `C_Item.GetItemIconByID`, `C_Item.GetItemID`, `C_Item.GetItemInfoInstant`, `C_Item.GetItemInventorySlotInfo`, `C_Item.GetItemInventorySlotKey`, `C_Item.GetItemInventoryType`, `C_Item.GetItemInventoryTypeByID`, `C_Item.GetItemLink`, `C_Item.GetItemLocation`, `C_Item.GetItemMaxStackSize`, `C_Item.GetItemMaxStackSizeByID`, `C_Item.GetItemName`, `C_Item.GetItemNameByID`, `C_Item.GetItemQuality`, `C_Item.GetItemQualityByID`, `C_Item.GetItemSellPrice`, `C_Item.GetItemSellPriceByID`, `C_Item.GetItemSetID`, `C_Item.GetItemSetIDByID`, `C_Item.GetItemSetInfo`, `C_Item.GetItemSpell`, `C_Item.GetItemStatDelta`, `C_Item.GetItemStats`, `C_Item.GetItemSubClassInfo`, `C_Item.GetItemUniqueness`, `C_Item.GetItemUniquenessByID`, `C_Item.GetStackCount`, `C_Item.GetWeaponEnchantInfo`, `C_Item.IsBound`, `C_Item.IsEquippableItem`, `C_Item.IsEquippedItem`, `C_Item.IsItemDataCached`, `C_Item.IsItemDataCachedByID`, `C_Item.IsItemGUIDInInventory`, `C_Item.IsItemOpenable`, `C_Item.IsLocked`, `C_Item.LockItem`, `C_Item.LockItemByGUID`, `C_Item.UnlockAllItems`, `C_Item.UnlockItem`, `C_Item.RequestLoadItemData`, `C_Item.RequestLoadItemDataByID`, `C_Item.UseAtCursor`, `C_Item.UseAtUnit`, `C_Item.UseItemByName`, `GetAuctionItemID`, `GetAuctionSellItemID`, `GetAverageItemLevel`, `GetCraftReagentItemID`, `GetInboxItemID`, `GetInventoryItemDurability`, `GetInventoryItemID`, `GetInventoryItemsForSlot`, `GetInventoryItemRepairCost`, `GetItemIcon`, `GetLootRollItemID`, `GetLootSlotItemID`, `GetMerchantItemID`, `GetQuestItemID`, `GetQuestLogItemID`, `GetTradePlayerItemID`, `GetTradeSkillItemID`, `GetTradeSkillReagentItemID`, `GetTradeTargetItemID`, `OffhandHasWeapon` |
 | [Loot](docs/API.md#loot) | `C_Loot.GetNearbyLootableUnits`, `C_Loot.GetLastScanResults`, `C_Loot.IsScanInProgress`, `C_Loot.LootUnit`, `C_Loot.LootUnitItem`, `C_Loot.ScanNearbyLoot` |
 | [Macros](docs/API.md#macros) | `GetLooseMacroIcons`, `GetLooseMacroItemIcons`, `GetMacroIcons`, `GetMacroItemIcons`, `GetMacroSpell` |
 | [Mail](docs/API.md#mail) | `GetInboxItemLink`, `GetSendMailItemLink` |
 | [Map](docs/API.md#map) | `C_Map.GetBestMapForUnit` |
 | [MerchantFrame](docs/API.md#merchantframe) | `C_MerchantFrame.GetBuybackItemID`, `C_MerchantFrame.GetItemInfo`, `C_MerchantFrame.GetNumJunkItems`, `C_MerchantFrame.IsMerchantItemRefundable`, `C_MerchantFrame.IsSellAllJunkEnabled`, `C_MerchantFrame.SellAllJunkItems` |
 | [NamePlate](docs/API.md#nameplate) | `C_NamePlate.GetNamePlateForGUID`, `C_NamePlate.GetNamePlateForUnit`, `C_NamePlate.GetNamePlateGUIDs`, `C_NamePlate.GetNamePlates` |
-| [NameCache](docs/API.md#namecache) | `C_CreatureInfo.GetCreatureID`, `C_PlayerCache.GetPlayerInfoByName`, `C_PlayerCache.IsEnabled`, `C_PlayerCache.IsScanEnabled`, `C_PlayerCache.RememberPlayer`, `C_PlayerCache.SetEnabled`, `C_PlayerCache.SetScanEnabled`, `C_PlayerInfo.GUIDIsCreature`, `C_PlayerInfo.GUIDIsGameObject`, `C_PlayerInfo.GUIDIsPet`, `C_PlayerInfo.GUIDIsPlayer`, `GetPlayerInfoByGUID`, `UnitNameFromGUID` |
+| [NameCache](docs/API.md#namecache) | `C_PlayerCache.GetPlayerInfoByName`, `C_PlayerCache.IsEnabled`, `C_PlayerCache.IsScanEnabled`, `C_PlayerCache.RememberPlayer`, `C_PlayerCache.SetEnabled`, `C_PlayerCache.SetScanEnabled`, `C_PlayerInfo.GUIDIsCreature`, `C_PlayerInfo.GUIDIsGameObject`, `C_PlayerInfo.GUIDIsPet`, `C_PlayerInfo.GUIDIsPlayer`, `GetPlayerInfoByGUID`, `UnitNameFromGUID` |
 | [Quest](docs/API.md#quest) | `C_QuestLog.GetQuestDetails`, `C_QuestLog.GetQuestIDForLogIndex`, `C_QuestLog.GetTitleForQuestID`, `C_QuestLog.IsOnQuest`, `C_QuestLog.IsQuestDataCachedByID`, `C_QuestLog.IsUnitOnQuest`, `C_QuestLog.RequestLoadQuestByID`, `GetQuestLogLeaderBoardID` |
 | [Screen](docs/API.md#screen) | `GetPhysicalScreenSize` |
-| [Spell](docs/API.md#spell) | `C_Spell.CancelSpellByID`, `C_Spell.CastAtCursor`, `C_Spell.CastAtUnit`, `C_Spell.DoesSpellExist`, `C_Spell.GetSchoolString`, `C_Spell.GetSpellCooldown`, `C_Spell.GetSpellDescription`, `C_Spell.GetSpellInfo`, `C_Spell.GetSpellLink`, `C_Spell.GetSpellMechanicByID`, `C_Spell.GetSpellName`, `C_Spell.GetSpellPowerCost`, `C_Spell.GetSpellRadius`, `C_Spell.GetSpellReagents`, `C_Spell.GetSpellSubtext`, `C_Spell.GetSpellTexture`, `C_Spell.IsAutoAttackSpell`, `C_Spell.IsCurrentSpell`, `C_Spell.IsRangedAutoAttackSpell`, `C_Spell.IsSelfBuff`, `C_Spell.IsSpellHarmful`, `C_Spell.IsSpellHelpful`, `C_Spell.IsSpellPassive`, `C_Spell.IsSpellUsable`, `C_Spell.SpellHasRange`, `CancelSpellByName`, `CastingInfo`, `CastSpellNoToggle`, `ChannelInfo`, `GetCraftSpellID`, `GetSpellInfo`, `GetSpellLink`, `GetSpellRadius`, `GetSpellSchool`, `IsHarmfulSpell`, `IsHelpfulSpell`, `IsPassiveSpell`, `IsPlayerSpell`, `IsSpellKnown`, `IsUsableSpell`, `SpellHasRange`, `UnitCastingInfo`, `UnitChannelInfo` |
+| [Spell](docs/API.md#spell) | `C_Spell.CancelSpellByID`, `C_Spell.CastAtCursor`, `C_Spell.CastAtUnit`, `C_Spell.CastingInfo`, `C_Spell.ChannelInfo`, `C_Spell.DoesSpellExist`, `C_Spell.GetSchoolString`, `C_Spell.GetSpellCooldown`, `C_Spell.GetSpellDescription`, `C_Spell.GetSpellInfo`, `C_Spell.GetSpellLink`, `C_Spell.GetSpellMechanicByID`, `C_Spell.GetSpellName`, `C_Spell.GetSpellPowerCost`, `C_Spell.GetSpellRadius`, `C_Spell.GetSpellReagents`, `C_Spell.GetSpellSubtext`, `C_Spell.GetSpellTexture`, `C_Spell.IsAutoAttackSpell`, `C_Spell.IsCurrentSpell`, `C_Spell.IsRangedAutoAttackSpell`, `C_Spell.IsSelfBuff`, `C_Spell.IsSpellHarmful`, `C_Spell.IsSpellHelpful`, `C_Spell.IsSpellPassive`, `C_Spell.IsSpellUsable`, `C_Spell.SpellHasRange`, `C_Spell.UnitCastingInfo`, `C_Spell.UnitChannelInfo`, `CancelSpellByName`, `CastSpellNoToggle`, `GetCraftSpellID`, `GetSpellInfo`, `GetSpellLink`, `GetSpellRadius`, `GetSpellSchool`, `IsHarmfulSpell`, `IsHelpfulSpell`, `IsPassiveSpell`, `IsPlayerSpell`, `IsSpellKnown`, `IsUsableSpell`, `SpellHasRange` |
 | [SpellBook](docs/API.md#spellbook) | `C_SpellBook.GetCurrentLevelSpells`, `C_SpellBook.GetSpellLevelLearned`, `C_SpellBook.GetSpellSkillLine`, `C_SpellBook.IsAutoAttackSpellBookItem`, `C_SpellBook.IsRangedAutoAttackSpellBookItem`, `FindSpellBookSlotByID` |
 | [State](docs/API.md#state) | `CancelShapeshiftForm`, `Dismount`, `GetMirrorTimerInfo`, `GetMirrorTimerProgress`, `GetShapeshiftFormID`, `IsAssistingRitual`, `IsFalling`, `IsInGroup`, `IsInRaid`, `IsLoggedIn`, `IsMounted`, `IsStealthed`, `IsSwimming` |
 | [Table](docs/API.md#table) | `table.wipe` |
 | [Talent](docs/API.md#talent) | `GetTalentIDByIndex`, `GetTalentSpellID` |
 | [Time](docs/API.md#time) | `C_DateAndTime.AdjustTimeByDays`, `C_DateAndTime.AdjustTimeByMinutes`, `C_DateAndTime.CompareCalendarTime`, `C_DateAndTime.GetCalendarTimeFromEpoch`, `C_DateAndTime.GetCurrentCalendarTime`, `C_DateAndTime.GetSecondsUntilDailyReset`, `C_DateAndTime.GetServerTimeLocal`, `C_Timer.After`, `C_Timer.NewTicker`, `C_Timer.NewTimer`, `GetServerTime` |
-| [UIColor](docs/API.md#uicolor) | `C_UIColor.GetColors` (backports `GlobalColor.dbc`; companion addon wraps each row with `ColorMixin` and assigns `_G[baseTag]` + `_G[baseTag.."_CODE"]`) |
+| [UIColor](docs/API.md#uicolor) | `C_UIColor.GetColors` |
 | [Unit](docs/API.md#unit) | `GetUnitSpeed`, `UnitClassBase`, `UnitGUID`, `UnitInRange`, `UnitIsAFK`, `UnitIsDND`, `UnitIsFeignDeath`, `UnitIsInMyGuild`, `UnitIsPossessed`, `UnitPower`, `UnitPowerMax`, `UnitPowerType`, `UnitRaceBase`, `UnitStandState`, `UnitSubName`, `UnitTokenFromGUID` |
 | [UnitAuras](docs/API.md#unitauras) | `C_UnitAuras.GetAuraDataByIndex`, `C_UnitAuras.GetAuraDataBySpellName`, `C_UnitAuras.GetAuraDispelTypeColor`, `C_UnitAuras.GetBuffDataByIndex`, `C_UnitAuras.GetDebuffDataByIndex`, `C_UnitAuras.GetPlayerAuraBySpellID`, `C_UnitAuras.GetUnitAuraBySpellID`, `C_UnitAuras.GetUnitAuras` |

@@ -99,6 +101,7 @@ when launching with `-console`), not as Lua functions. See the
 |---------|--------------|
 | `ExportInterfaceFiles code` | Extracts Blizzard's UI source (`.lua`/`.xml`/`.toc`/`.xsd`) from the MPQs to `BlizzardInterfaceCode\` |
 | `ExportInterfaceFiles art` | Extracts Blizzard's UI art (`.blp`/`.tga`) from the MPQs to `BlizzardInterfaceArt\` |
+| `ExportDBCFiles` | Extracts the client's `.dbc` tables from the MPQs to `DBFilesClient\` |

 ### Events

@@ -140,6 +143,7 @@ when launching with `-console`), not as Lua functions. See the
 | Unit stat | `LE_UNIT_STAT_STRENGTH` … `LE_UNIT_STAT_SPIRIT` |
 | Addon security | `Enum.AddOnSecurityStatus.{Secure,Insecure,Banned,NotAvailable}` |
 | Power type | `Enum.PowerType.{HealthCost,None,Mana,Rage,Focus,Energy,Happiness}` |
+| Inventory type | `Enum.InventoryType.Index*Type` (0–34, e.g. `IndexHeadType`=1 … `IndexRelicType`=28) |

 ### Unit tokens

@@ -163,14 +167,19 @@ See [Focus / Bindings](docs/API.md#bindings-focustarget--targetfocus) for the im

 ## Installation

-Use [VanillaFixes](https://github.com/hannesmann/vanillafixes) to load the
-DLL.
+Download the prebuilt `ClassicAPI.dll` from the
+[latest release](https://github.com/brues-code/ClassicAPI/releases/latest)
+(or [build it yourself](#building)). It's loaded with
+[VanillaFixes](https://github.com/hannesmann/vanillafixes):

 1. Install VanillaFixes if it isn't already.
 2. Copy `ClassicAPI.dll` into your game directory.
 3. Add `ClassicAPI.dll` to `dlls.txt`.
 4. Launch the game with `VanillaFixes.exe`.

+The bundled `!!!ClassicAPI` addon ships *inside* the DLL — no separate
+addon download or install step needed.
+
 ## Bundled addon: !!!ClassicAPI

 The Lua-side companion library lives in
@@ -257,4 +266,4 @@ at configure time; the value exposed to Lua will be `X*10000 + Y*100 + Z`.

 ## License

-LGPL v3 or later. See the headers in `src/` for the full notice.
+GPL v3 or later. See the headers in `src/` for the full notice.
@@ -35,6 +35,7 @@ build instructions.

 - [Console](#console)
  - [`ExportInterfaceFiles art|code` (console command)](#exportinterfacefiles-artcode-console-command)
+  - [`ExportDBCFiles` (console command)](#exportdbcfiles-console-command)

 - [Container](#container)
  - [`C_Container.GetContainerItemID(bagIndex, slotIndex)`](#c_containergetcontaineritemidbagindex-slotindex)
@@ -57,6 +58,11 @@ build instructions.
  - [`coroutine.wrap(fn)`](#coroutinewrapfn)
  - [Async pattern (RunAsync + C_Timer.After)](#async-pattern-runasync--c_timerafter)

+- [Creature](#creature)
+  - [`C_CreatureInfo.GetCreatureID(guid)`](#c_creatureinfogetcreatureidguid)
+  - [`C_CreatureInfo.GetCreatureInfoByID(creatureID)`](#c_creatureinfogetcreatureinfobyidcreatureid)
+  - [`C_CreatureInfo.RequestLoadCreatureByID(creatureID)`](#c_creatureinforequestloadcreaturebyidcreatureid)
+
 - [CVar](#cvar)
  - [`C_CVar.GetCVarBool(cvar)`](#c_cvargetcvarboolcvar)

@@ -125,6 +131,10 @@ build instructions.
  - [`C_FriendList.SendWhoQueryByName(name)`](#c_friendlistsendwhoquerybynamename)
  - [`C_FriendList.IsWhoQueryPending()`](#c_friendlistiswhoquerypending)

+- [GameObject](#gameobject)
+  - [`C_GameObjectInfo.GetGameObjectInfoByID(gameObjectID)`](#c_gameobjectinfogetgameobjectinfobyidgameobjectid)
+  - [`C_GameObjectInfo.RequestLoadGameObjectByID(gameObjectID)`](#c_gameobjectinforequestloadgameobjectbyidgameobjectid)
+
 - [GameTooltip](#gametooltip)
  - [`GameTooltip:SetSpellByID(spellID)`](#gametooltipsetspellbyidspellid)
  - [`GameTooltip:SetTalentByID(talentID)`](#gametooltipsettalentbyidtalentid)
@@ -144,6 +154,7 @@ build instructions.
  - [`LE_ITEM_QUALITY_*`](#le_item_quality_)
  - [`LE_UNIT_STAT_*`](#le_unit_stat_)
  - [`Enum.AddOnSecurityStatus`](#enumaddonsecuritystatus)
+  - [`Enum.InventoryType`](#enuminventorytype)
  - [`Enum.PowerType`](#enumpowertype)

 - [Gossip](#gossip)
@@ -180,6 +191,8 @@ build instructions.
  - [`C_Item.GetItemGUID(itemLocation)`](#c_itemgetitemguiditemlocation)
  - [`C_Item.GetItemID(itemLocation)`](#c_itemgetitemiditemlocation)
  - [`C_Item.GetItemInfoInstant(item)`](#c_itemgetiteminfoinstantitem)
+  - [`C_Item.GetItemInventorySlotInfo(inventorySlot)`](#c_itemgetiteminventoryslotinfoinventoryslot)
+  - [`C_Item.GetItemInventorySlotKey(inventorySlot)`](#c_itemgetiteminventoryslotkeyinventoryslot)
  - [`C_Item.GetItemInventoryType(itemLocation)` / `C_Item.GetItemInventoryTypeByID(item)`](#c_itemgetiteminventorytypeitemlocation--c_itemgetiteminventorytypebyiditem)
  - [`C_Item.GetItemLink(itemLocation)`](#c_itemgetitemlinkitemlocation)
  - [`C_Item.GetItemLocation(itemGUID)`](#c_itemgetitemlocationitemguid)
@@ -190,12 +203,16 @@ build instructions.
  - [`C_Item.GetItemSetID(itemLocation)` / `C_Item.GetItemSetIDByID(item)`](#c_itemgetitemsetiditemlocation--c_itemgetitemsetidbyiditem)
  - [`C_Item.GetItemSetInfo(setID)`](#c_itemgetitemsetinfosetid)
  - [`C_Item.GetItemSpell(item)`](#c_itemgetitemspellitem)
+  - [`C_Item.GetItemStatDelta(itemLink1, itemLink2)`](#c_itemgetitemstatdeltaitemlink1-itemlink2)
+  - [`C_Item.GetItemStats(itemLink)`](#c_itemgetitemstatsitemlink)
+  - [`C_Item.GetItemSubClassInfo(classID, subClassID)`](#c_itemgetitemsubclassinfoclassid-subclassid)
  - [`C_Item.GetItemUniqueness(itemLocation)` / `C_Item.GetItemUniquenessByID(item)`](#c_itemgetitemuniquenessitemlocation--c_itemgetitemuniquenessbyiditem)
  - [`C_Item.GetStackCount(itemLocation)`](#c_itemgetstackcountitemlocation)
  - [`C_Item.IsBound(itemLocation)`](#c_itemisbounditemlocation)
  - [`C_Item.IsEquippableItem(item)`](#c_itemisequippableitemitem)
  - [`C_Item.IsEquippedItem(item)`](#c_itemisequippeditemitem)
  - [`C_Item.IsItemDataCachedByID(item)` / `C_Item.IsItemDataCached(itemLocation)`](#c_itemisitemdatacachedbyiditem--c_itemisitemdatacacheditemlocation)
+  - [`C_Item.IsItemGUIDInInventory(itemGUID)`](#c_itemisitemguidininventoryitemguid)
  - [`C_Item.IsItemOpenable(itemLocation)`](#c_itemisitemopenableitemlocation)
  - [`C_Item.IsLocked(itemLocation)`](#c_itemislockeditemlocation)
  - [`C_Item.LockItem(itemLocation)`](#c_itemlockitemitemlocation)
@@ -256,7 +273,6 @@ build instructions.
  - [`UnitNameFromGUID(guid)`](#unitnamefromguidguid)
  - [`C_PlayerCache.GetPlayerInfoByName(name)`](#c_playercachegetplayerinfobynamename)
  - [`C_PlayerInfo.GUIDIsPlayer(guid)` / `GUIDIsCreature` / `GUIDIsPet` / `GUIDIsGameObject`](#c_playerinfoguidisplayerguid--guidiscreature--guidispet--guidisgameobject)
-  - [`C_CreatureInfo.GetCreatureID(guid)`](#c_creatureinfogetcreatureidguid)
  - [`C_PlayerCache.RememberPlayer(guid, name, classToken)`](#c_playercacherememberplayerguid-name-classtoken)
  - [`C_PlayerCache.SetEnabled(enabled)`](#c_playercachesetenabledenabled)
  - [`C_PlayerCache.IsEnabled()`](#c_playercacheisenabled)
@@ -310,8 +326,8 @@ build instructions.
  - [`C_Spell.CastAtCursor(spellID)`](#c_spellcastatcursorspellid)
  - [`C_Spell.CastAtUnit(spellID, unit)`](#c_spellcastatunitspellid-unit)
  - [`C_Spell.CancelSpellByID(spellID)` / `CancelSpellByName(name)`](#c_spellcancelspellbyidspellid--cancelspellbynamename)
-  - [`UnitCastingInfo(unit)` / `CastingInfo()`](#unitcastinginfounit--castinginfo)
-  - [`UnitChannelInfo(unit)` / `ChannelInfo()`](#unitchannelinfounit--channelinfo)
+  - [`C_Spell.UnitCastingInfo(unit)` / `C_Spell.CastingInfo()`](#c_spellunitcastinginfounit--c_spellcastinginfo)
+  - [`C_Spell.UnitChannelInfo(unit)` / `C_Spell.ChannelInfo()`](#c_spellunitchannelinfounit--c_spellchannelinfo)

 - [SpellBook](#spellbook)
  - [`FindSpellBookSlotByID(spellID)`](#findspellbookslotbyidspellid)
@@ -878,6 +894,37 @@ Notes:
 - It runs synchronously and briefly freezes the client while it walks
  `Interface\` — expected for a one-shot extraction.

+### `ExportDBCFiles` (console command)
+
+A ClassicAPI-original companion to `ExportInterfaceFiles` that dumps
+every `.dbc` table the client loads to `DBFilesClient\` under the working
+directory (next to `WoW.exe`). No subcommand — there's only one thing to
+export.
+
+```
+> ExportDBCFiles
+ExportDBCFiles: wrote 155 .dbc file(s) to DBFilesClient\
+```
+
+Unlike the MPQ `(listfile)` alone (which omits ~18 of the tables the
+client actually loads — mostly cosmetic animation/sound/lookup DBCs that
+Blizzard left out of the index), this unions two sources for a complete
+set:
+
+1. the **MPQ `(listfile)`** under `DBFilesClient\` — catches files that
+   ship in the archives without a loader (e.g. `wowerror_strings.dbc`);
+2. a **`.text` scan for the DBC path-getter pattern**
+   (`mov eax, &"DBFilesClient\X.dbc"; ret`) — the authoritative list of
+   what this build loads. The master DBC init (`FUN_0053f8b0`) is
+   straight-line with no iterable name table, so the per-DBC getters
+   *are* the registry; scanning for them is the same technique that
+   built [docs/DBCs.md](DBCs.md).
+
+Results are deduped case-insensitively. Handy for a local DBC dump to
+inspect schemas/values directly — e.g. verifying a record's column
+layout against a known row, the way `C_Item.GetEnchantInfo`'s effect
+columns were confirmed — without a standalone MPQ extraction tool.
+
 ## Container

 ### `C_Container.GetContainerItemID(bagIndex, slotIndex)`
@@ -1429,6 +1476,114 @@ fires on the next OnUpdate tick). `RunNextFrame(cb)` in
 [`AddOns/!!!ClassicAPI/Util/FunctionUtil.lua`](../AddOns/!!!ClassicAPI/Util/FunctionUtil.lua)
 wraps the same primitive for the non-coroutine case.

+## Creature
+
+### `C_CreatureInfo.GetCreatureID(guid)`
+
+Extracts the creature template / NPC ID from a unit GUID. Vanilla
+1.12 packs the entry ID directly into bits 24-47 of the 64-bit
+GUID for the types that carry one; this function does the shift
+and mask so addons don't have to.
+
+```lua
+C_CreatureInfo.GetCreatureID(UnitGUID("target"))   -- 1842 for Hogger
+C_CreatureInfo.GetCreatureID(UnitGUID("pet"))      -- pet's creature template ID
+C_CreatureInfo.GetCreatureID(UnitGUID("player"))   -- nil (no entry on players)
+```
+
+Accepts creature GUIDs (`0xF130xxxx…`) and pet GUIDs
+(`0xF140xxxx…`). Returns `nil` for:
+- non-string input or malformed GUIDs
+- player GUIDs — the low 32 bits hold a player ID, not a template
+- game-object / dynamic-object / corpse / item GUIDs — modern's
+  `C_CreatureInfo` doesn't surface entry IDs for these even though
+  the bits are in the same range; addons that need them can shift
+  the raw GUID themselves (`(guid >> 24) & 0xFFFFFF`)
+- entry IDs of 0 — the engine never assigns 0; treated as "no info"
+
+The standard 16-digit (`"0xHHHHHHHHLLLLLLLL"`) and 8-digit
+(`"0xLLLLLLLL"`) GUID-string forms are both accepted, the same forms
+the `C_PlayerInfo.GUIDIs*` functions take.
+
+The creatureID this returns is exactly what
+[`C_CreatureInfo.GetCreatureInfoByID`](#c_creatureinfogetcreatureinfobyidcreatureid)
+takes — `GetCreatureInfoByID(GetCreatureID(UnitGUID("target")))` gives
+the target's cached name/type/family/rank.
+
+### `C_CreatureInfo.GetCreatureInfoByID(creatureID)`
+
+Reads the client-side **creature cache** (`creaturecache.wdb`, fed by
+`SMSG_CREATURE_QUERY_RESPONSE`) for an NPC/creature by ID and returns a
+table — or `nil` if it isn't cached:
+
+```lua
+local info = C_CreatureInfo.GetCreatureInfoByID(61332)
+-- {
+--   creatureID = 61332,
+--   name       = "Misthoof Stag",
+--   subName    = "",     -- title/subtitle ("" if none)
+--   type       = 1,      -- CreatureType: 1=Beast, 7=Humanoid, …
+--   family     = 0,      -- CreatureFamily
+--   rank       = 0,      -- 0=normal, 1=elite, 2=rareelite, 3=worldboss, 4=rare
+--   displayID  = 10957,  -- model display ID
+-- }
+```
+
+This is a synchronous **peek** — it returns data only for creatures
+already cached (seen this session, or loaded from `creaturecache.wdb`
+at login), and `nil` otherwise. Unlike `UnitCreatureType`/
+`UnitClassification`, which only work on a *live unit token*, this
+answers for any creatureID you have cached — even one not currently in
+the world.
+
+Reads through the engine's generic cache `_GetRecord` (with no callback,
+so it's a pure lookup — no network query) and pulls the fields straight
+off the cached data block. Field offsets verified against the binary
+(rank read by the engine's classification helper at `[block+0x20]`) and
+real `creaturecache.wdb` rows (Misthoof Stag→type 1, Nordrassil
+Nymph→type 7 rank 1, Greathorn Hunter→family 26).
+
+For a creature that isn't cached yet, call
+[`RequestLoadCreatureByID`](#c_creatureinforequestloadcreaturebyidcreatureid)
+first and read it once `CREATURE_DATA_LOAD_RESULT` fires.
+
+### `C_CreatureInfo.RequestLoadCreatureByID(creatureID)`
+
+Asynchronously fetches a creature that isn't in the cache yet — issues
+`SMSG_CREATURE_QUERY` and fires **`CREATURE_DATA_LOAD_RESULT(creatureID,
+success)`** when the response lands, at which point
+[`GetCreatureInfoByID`](#c_creatureinfogetcreatureinfobyidcreatureid)
+returns its data. The same shape as
+[`C_Item.RequestLoadItemData`](#c_itemrequestloaditemdatabyiditem--c_itemrequestloaditemdataitemlocation).
+
+```lua
+local f = CreateFrame("Frame")
+f:RegisterEvent("CREATURE_DATA_LOAD_RESULT")
+f:SetScript("OnEvent", function()
+    -- 1.12 passes event args as globals: arg1 = creatureID, arg2 = success
+    if arg2 then
+        local info = C_CreatureInfo.GetCreatureInfoByID(arg1)
+        -- info.name, info.type, info.rank, …
+    end
+end)
+
+C_CreatureInfo.RequestLoadCreatureByID(10184)   -- Onyxia → fires the event,
+                                                --  then GetCreatureInfoByID works
+```
+
+Returns `true` if the request was accepted (`false` only on bad input
+or a full pending set). If the creature is **already** cached, the
+event fires synchronously with `success = true`. On a query that never
+resolves it fires once with `success = false` after a timeout.
+
+Implementation: a shared `Cache::QueryLoad` dispatcher hooks the engine's
+generic cache response parser (`FUN_00556E20`) **once** and routes by
+cache instance — the same hook serves the gameobject cache too. The
+creature/gameobject caches use this generic parser; the item and quest
+caches have their own, so there's no hook collision. Verified in-game: `RequestLoadCreatureByID(10184)` on
+an uncached Onyxia fired the event and populated the cache (type 2
+Dragonkin, rank 3 world boss).
+
 ## CVar

 ### `C_CVar.GetCVarBool(cvar)`
@@ -2856,6 +3011,48 @@ contribute to the same pending window. This is acceptable for the
 addons that need per-call tracking should manage their own ticket
 state on top.

+## GameObject
+
+The gameobject analog of [`C_CreatureInfo`](#creature) — reads the
+client-side gameobject cache (`gameobjectcache.wdb`, fed by
+`SMSG_GAMEOBJECT_QUERY_RESPONSE`) by GO entry ID.
+
+### `C_GameObjectInfo.GetGameObjectInfoByID(gameObjectID)`
+
+Synchronous **peek** — returns a table for a cached gameobject, `nil`
+otherwise:
+
+```lua
+local info = C_GameObjectInfo.GetGameObjectInfoByID(47297)
+-- { gameObjectID = 47297, name = "Mesa Elevator", type = 11, displayID = 360 }
+```
+
+`type` is the `GameObjectType` (0=door, 1=button, 3=chest, 5=generic,
+6=trap, 10=goober, …). Field offsets verified against the binary
+(name `[block+0x08]`) and real `gameobjectcache.wdb` rows (Mesa
+Elevator 47297→type 11; Windrunner 176250→type 15 displayID 7087).
+
+### `C_GameObjectInfo.RequestLoadGameObjectByID(gameObjectID)`
+
+Asynchronously fetches an uncached gameobject — issues
+`SMSG_GAMEOBJECT_QUERY` and fires **`GAMEOBJECT_DATA_LOAD_RESULT(
+gameObjectID, success)`** when it lands, after which
+`GetGameObjectInfoByID` returns its data. Returns `true` if accepted;
+fires synchronously on a cache hit. Same shape as
+[`C_CreatureInfo.RequestLoadCreatureByID`](#c_creatureinforequestloadcreaturebyidcreatureid),
+and rides the same shared `Cache::QueryLoad` dispatcher (the gameobject
+cache is a sibling class of the creature cache with its own
+`_GetRecord`/parser, hooked separately).
+
+```lua
+local f = CreateFrame("Frame")
+f:RegisterEvent("GAMEOBJECT_DATA_LOAD_RESULT")
+f:SetScript("OnEvent", function()  -- arg1 = gameObjectID, arg2 = success
+    if arg2 then local info = C_GameObjectInfo.GetGameObjectInfoByID(arg1) end
+end)
+C_GameObjectInfo.RequestLoadGameObjectByID(7000032)
+```
+
 ## GameTooltip

 ### `GameTooltip:SetItemByID(itemID)`
@@ -3423,6 +3620,39 @@ if C_AddOns.GetAddOnSecurity(name) == Enum.AddOnSecurityStatus.Secure then
 end
 ```

+### `Enum.InventoryType`
+
+The equip-type enum — the numeric `inventoryType` reported by
+[`C_Item.GetItemInfoInstant`](#c_itemgetiteminfoinstantitem) /
+[`C_Item.GetItemInventoryType`](#c_itemgetiteminventorytypeitemlocation--c_itemgetiteminventorytypebyiditem),
+and the argument the `C_Item.GetItemInventorySlot*` functions take.
+
+| Value | Field | Value | Field |
+|------:|-------|------:|-------|
+| 0 | `IndexNonEquipType` | 15 | `IndexRangedType` |
+| 1 | `IndexHeadType` | 16 | `IndexCloakType` |
+| 2 | `IndexNeckType` | 17 | `Index2HweaponType` |
+| 3 | `IndexShoulderType` | 18 | `IndexBagType` |
+| 4 | `IndexBodyType` | 19 | `IndexTabardType` |
+| 5 | `IndexChestType` | 20 | `IndexRobeType` |
+| 6 | `IndexWaistType` | 21 | `IndexWeaponmainhandType` |
+| 7 | `IndexLegsType` | 22 | `IndexWeaponoffhandType` |
+| 8 | `IndexFeetType` | 23 | `IndexHoldableType` |
+| 9 | `IndexWristType` | 24 | `IndexAmmoType` |
+| 10 | `IndexHandType` | 25 | `IndexThrownType` |
+| 11 | `IndexFingerType` | 26 | `IndexRangedrightType` |
+| 12 | `IndexTrinketType` | 27 | `IndexQuiverType` |
+| 13 | `IndexWeaponType` | 28 | `IndexRelicType` |
+| 14 | `IndexShieldType` | | |
+
+Values `29..34` (`IndexProfessionToolType`, `IndexProfessionGearType`,
+`IndexEquipablespell{Offensive,Utility,Defensive,Weapon}Type`) are
+post-vanilla and included for parity — vanilla items never report them.
+
+```lua
+if C_Item.GetItemInventoryType(loc) == Enum.InventoryType.IndexHeadType then ...
+```
+
 ### `Enum.PowerType`

 The integer enum `UnitPowerType` returns and `UnitPower` /
@@ -4180,6 +4410,25 @@ Silk Cloth lives at `(7, 0)` in this client, not the modern `(7, 5)`.
 > explicitly, or just call `GetItemInfo` (which warms via the
 > `Script_GetItemInfo` hook).

+### `C_Item.GetItemInventorySlotInfo(inventorySlot)`
+
+Returns the localized display name for an `Enum.InventoryType` value — e.g.
+`C_Item.GetItemInventorySlotInfo(1)` → `"Head"`. Returns `nil` for the
+non-equip slot (`0`) or out-of-range values.
+
+The engine's INVTYPE table stores the equipLoc *key* (`"INVTYPE_HEAD"`); the
+display name is the FrameXML global string of that key (`INVTYPE_HEAD =
+"Head"`), so the result is correctly localized on non-English clients.
+
+### `C_Item.GetItemInventorySlotKey(inventorySlot)`
+
+Returns the equipLoc key string for an `Enum.InventoryType` value — e.g.
+`C_Item.GetItemInventorySlotKey(1)` → `"INVTYPE_HEAD"`. This is the same
+`INVTYPE_*` token [`C_Item.GetItemInfoInstant`](#c_itemgetiteminfoinstantitem)
+returns as its `itemEquipLoc`. Returns `nil` for the non-equip slot (`0`) or
+out-of-range values. Pair it with `GetItemInventorySlotInfo` to turn the key
+into a localized label.
+
 ### `C_Item.GetItemInventoryType(itemLocation)` / `C_Item.GetItemInventoryTypeByID(item)`

 Returns the numeric `Enum.InventoryType` straight off the cache
@@ -4433,6 +4682,118 @@ request. A second call after `GET_ITEM_INFO_RECEIVED` lands the
 data. Same warmup pattern as `C_Item.GetItemFamily` and the rest of
 our cache-backed accessors.

+### `C_Item.GetItemStatDelta(itemLink1, itemLink2)`
+
+Returns a table of the per-stat **difference** between two items,
+computed as `item2 - item1` — a positive value means the second item has
+more of that stat. Only stats whose delta is non-zero appear.
+
+```lua
+-- Compare an equipped ring against one in your bags:
+local delta = C_Item.GetItemStatDelta(
+    C_Item.GetItemLink({equipmentSlotIndex = 11}),
+    C_Item.GetItemLink({bagID = 0, slotIndex = 3}))
+-- delta = { ITEM_MOD_INTELLECT_SHORT = 6, ITEM_MOD_SPIRIT_SHORT = 2 }
+-- (the bag ring has +6 Int / +2 Spirit relative to the equipped one)
+```
+
+Same key set, accepted input forms, random-suffix handling, and caching
+caveat as [`C_Item.GetItemStats`](#c_itemgetitemstatsitemlink) — see
+there for the details. Returns `nil` if **either** item is uncached.
+
+### `C_Item.GetItemStats(itemLink)`
+
+Returns a table of an item's stats, keyed by the FrameXML global-string
+names WoW's own `GetItemStats` uses (so `_G[key]` yields the display
+label — `_G["ITEM_MOD_STRENGTH_SHORT"]` → `"Strength"`). Only stats the
+item actually carries are present.
+
+```lua
+C_Item.GetItemStats("item:2244")            -- Krol Blade
+-- { ITEM_MOD_STRENGTH_SHORT = 7, ITEM_MOD_STAMINA_SHORT = 5,
+--   ITEM_MOD_DAMAGE_PER_SECOND_SHORT = 40.89,
+--   ITEM_MOD_CRIT_MELEE_RATING = 1, ITEM_MOD_CRIT_RANGED_RATING = 1 }
+
+C_Item.GetItemStats("item:12022:0:769")     -- "of the Owl" random suffix
+-- { ITEM_MOD_INTELLECT_SHORT = 6, ITEM_MOD_SPIRIT_SHORT = 6 }
+```
+
+**Sources.** The table is assembled from three places, so it reflects
+what the item actually grants — not just its stored stat slots:
+
+1. **Base record** — the stored attributes, armor, resistances, and (for
+   weapons) DPS.
+2. **On-equip spells** (`SpellTrigger == ON_EQUIP`) — vanilla stores the
+   "special" bonuses (crit, attack power, spell power, hit, mp5, defense,
+   …) as an equip spell whose aura effect carries the value, not as a
+   stat slot. Their auras are decoded into the keys below.
+3. **Random suffix** — the link's third `item:id:enchant:SUFFIX:unique`
+   field (`ItemRandomProperties.dbc` → `SpellItemEnchantment.dbc`): stat
+   suffixes ("of the Owl") are themselves equip spells, armor suffixes
+   ("of Toughness") are direct resistance enchants. A bare itemID or a
+   suffix-less link contributes nothing here.
+
+**Keys.**
+
+| Key | Stat | Source |
+|-----|------|--------|
+| `ITEM_MOD_STRENGTH_SHORT` / `_AGILITY_` / `_STAMINA_` / `_INTELLECT_` / `_SPIRIT_SHORT` | Base attributes | record / `MOD_STAT` |
+| `ITEM_MOD_MANA_SHORT` / `ITEM_MOD_HEALTH_SHORT` | Mana / health on equip | record |
+| `RESISTANCE0_NAME` | Armor | record / `MOD_RESISTANCE` bit 0 |
+| `RESISTANCE1_NAME` … `RESISTANCE6_NAME` | Holy / Fire / Nature / Frost / Shadow / Arcane resistance | record / `MOD_RESISTANCE` / type-4 enchant |
+| `ITEM_MOD_DAMAGE_PER_SECOND_SHORT` | Weapon DPS (float) | avg damage ÷ swing time |
+| `ITEM_MOD_ATTACK_POWER_SHORT` | Attack power | `MOD_ATTACK_POWER` (99) |
+| `ITEM_MOD_RANGED_ATTACK_POWER_SHORT` | Ranged attack power (ranged-only items) | `MOD_RANGED_ATTACK_POWER` (124) |
+| `ITEM_MOD_CRIT_MELEE_RATING` + `ITEM_MOD_CRIT_RANGED_RATING` | Crit % | weapon-crit aura (52) |
+| `ITEM_MOD_HIT_MELEE_RATING` + `ITEM_MOD_HIT_RANGED_RATING` | Hit % | hit aura (54) |
+| `ITEM_MOD_HIT_SPELL_RATING` | Spell hit % | spell-hit aura (55) |
+| `ITEM_MOD_SPELL_DAMAGE_DONE_SHORT` | Spell damage | `MOD_DAMAGE_DONE` (13) |
+| `ITEM_MOD_SPELL_HEALING_DONE_SHORT` | Healing | `MOD_HEALING_DONE` (135) |
+| `ITEM_MOD_MANA_REGENERATION` | mp5 (mana) | `MOD_POWER_REGEN` (85) |
+| `ITEM_MOD_DEFENSE_SKILL_RATING` | Defense skill | `MOD_SKILL` (30, misc 95) |
+
+> **Values are vanilla-native, not ratings.** Vanilla has no rating
+> system, so the percent-based stats (crit / hit / defense) report the raw
+> **percentage** under the modern `*_RATING` key — e.g. Krol Blade's
+> "+1% crit" is `ITEM_MOD_CRIT_MELEE_RATING = 1`, where TBC/Era would
+> show the level-scaled rating (`13`). A native percent is the only
+> value that's honest and level-independent. Flat stats (attack power,
+> spell damage, healing, mp5) are the item's actual magnitudes.
+>
+> Rating stats that didn't exist in 1.12 at all (haste, mastery,
+> versatility, expertise, resilience) never appear. A generic "+N attack
+> power" item carries both a melee and a ranged AP aura in vanilla; the
+> generic `ITEM_MOD_ATTACK_POWER_SHORT` key subsumes it, so
+> `ITEM_MOD_RANGED_ATTACK_POWER_SHORT` shows only for ranged-only items
+> (scopes, ranged weapons). Rarer auras with no clean single key —
+> percent attack power, per-weapon-line skill, damage-taken, on-hit /
+> on-use procs — are skipped.
+
+**Input.** Accepts a full chat hyperlink, an `item:N…` link string, or a
+bare itemID (a superset of retail, which is link-only). Returns `nil` if
+the item isn't cached yet — warm it via `GetItemInfo` and retry.
+
+### `C_Item.GetItemSubClassInfo(classID, subClassID)`
+
+Returns `subClassName, subClassUsesInvType` for an item class/subclass pair.
+
+```lua
+C_Item.GetItemSubClassInfo(2, 7)   -- "One-Handed Swords", false
+C_Item.GetItemSubClassInfo(4, 1)   -- "Cloth", true
+```
+
+- `subClassName` (string) — the localized `ItemSubClass.dbc` name (verbose
+  form, e.g. `"One-Handed Swords"`; falls back to the short form for
+  subclasses that only populate it, e.g. `"Consumable"`).
+- `subClassUsesInvType` (boolean) — true for subclasses whose items are
+  labeled by inventory slot rather than by subclass name. On vanilla data
+  that's exactly the armor material types (Miscellaneous, Cloth, Leather,
+  Mail, Plate); false for weapons, shields, librams, idols, totems, and
+  non-equipment. Read from the `ItemSubClass.dbc` flags bit `0x200`
+  (verified against the 1.15 client).
+
+Returns `nil` if the `(classID, subClassID)` pair has no row.
+
 ### `C_Item.GetItemUniqueness(itemLocation)` / `C_Item.GetItemUniquenessByID(item)`

 The two functions have **different signatures** in modern (Classic
@@ -4577,6 +4938,24 @@ if not C_Item.IsItemDataCachedByID(itemID) then
 end
 ```

+### `C_Item.IsItemGUIDInInventory(itemGUID)`
+
+Returns whether the item with the given `"0x…"` GUID is currently carried
+by the player — the 19 equipment slots plus the bags (backpack + the four
+equipped bags). Equipped items count (verified against retail); the bank
+does not.
+
+```lua
+local g = C_Item.GetItemGUID({bagID = 0, slotIndex = 1})
+C_Item.IsItemGUIDInInventory(g)   -- true
+C_Item.IsItemGUIDInInventory(
+    C_Item.GetItemGUID({equipmentSlotIndex = 1}))   -- true (equipped counts)
+```
+
+Accepts the GUID string [`C_Item.GetItemGUID`](#c_itemgetitemguiditemlocation)
+/ `UnitGUID` return; returns `false` for a malformed or zero GUID. To also
+cover the bank, use `C_Item.GetItemCount(itemID, true) > 0` instead.
+
 ### `C_Item.IsItemOpenable(itemLocation)`

 Returns two values: `(isOpenable, canOpen)`.
@@ -6248,33 +6627,6 @@ Accepts either the 16-digit `"0xHHHHHHHHLLLLLLLL"` form or the
 Malformed input returns `false` rather than raising — matching
 modern's tolerance for stale GUIDs from addon-side caches.

-### `C_CreatureInfo.GetCreatureID(guid)`
-
-Extracts the creature template / NPC ID from a unit GUID. Vanilla
-1.12 packs the entry ID directly into bits 24-47 of the 64-bit
-GUID for the types that carry one; this function does the shift
-and mask so addons don't have to.
-
-```lua
-C_CreatureInfo.GetCreatureID(UnitGUID("target"))   -- 1842 for Hogger
-C_CreatureInfo.GetCreatureID(UnitGUID("pet"))      -- pet's creature template ID
-C_CreatureInfo.GetCreatureID(UnitGUID("player"))   -- nil (no entry on players)
-```
-
-Accepts creature GUIDs (`0xF130xxxx…`) and pet GUIDs
-(`0xF140xxxx…`). Returns `nil` for:
- non-string input or malformed GUIDs
- player GUIDs — the low 32 bits hold a player ID, not a template
- game-object / dynamic-object / corpse / item GUIDs — modern's
-  `C_CreatureInfo` doesn't surface entry IDs for these even though
-  the bits are in the same range; addons that need them can shift
-  the raw GUID themselves (`(guid >> 24) & 0xFFFFFF`)
- entry IDs of 0 — the engine never assigns 0; treated as "no info"
-
-The standard 16-digit (`"0xHHHHHHHHLLLLLLLL"`) and 8-digit
-(`"0xLLLLLLLL"`) GUID-string forms are both accepted, same as
-`C_PlayerInfo.GUIDIs*` above.
-
 ### `C_PlayerCache.SetEnabled(enabled)`

 Opts into (or out of) the persistent name cache. `enabled` is a
@@ -7756,21 +8108,31 @@ pass the plain name. Multi-rank buffs match on first-found; if you
 have multiple ranks of the same buff active (unusual but possible with
 e.g. paladin blessings before talent merge), the first slot wins.

-### `UnitCastingInfo(unit)` / `CastingInfo()`
+### `C_Spell.UnitCastingInfo(unit)` / `C_Spell.CastingInfo()`

 Returns the unit's in-progress **regular cast** (not a channel), or
-`nil` if it isn't casting. `CastingInfo()` is `UnitCastingInfo("player")`
-without the unit-token lookup.
+`nil` if it isn't casting. `C_Spell.CastingInfo()` is
+`C_Spell.UnitCastingInfo("player")` without the unit-token lookup.
+
+> **Under `C_Spell`, not the global `UnitCastingInfo`.** Modern WoW
+> exposes these as globals, but a global here would clobber addons that
+> ship their own vanilla cast-tracking via the `_G.UnitCastingInfo or
+> <fallback>` idiom — e.g. ShaguTweaks' `libcast` scrapes the combat
+> log for **remote/enemy** casts the 1.12 engine never exposes. If we
+> occupied the global, those addons would adopt our player-only version
+> and lose their (superior, for that case) fallback. So we cede the
+> global names and register under `C_Spell` instead. Same for
+> `UnitChannelInfo`/`ChannelInfo`.

 ```
 name, displayName, textureID, startTimeMs, endTimeMs, isTradeskill,
  castID, notInterruptible, castingSpellID, castBarID, delayTimeMs
-    = UnitCastingInfo(unit)
+    = C_Spell.UnitCastingInfo(unit)
 ```

 ```lua
 -- mid-cast:
-UnitCastingInfo("player")
+C_Spell.UnitCastingInfo("player")
 -- "Conjure Food", "Conjure Food", "Interface\\Icons\\INV_Misc_Food_...",
 --  907928268, 907931268, false, nil, false, 28612, nil, 0
 ```
@@ -7778,15 +8140,27 @@ UnitCastingInfo("player")
 `startTimeMs`/`endTimeMs` share `GetTime()`'s epoch (`GetTime()*1000`),
 so progress is `(GetTime()*1000 - startTimeMs) / (endTimeMs - startTimeMs)`.

-> **Local player only.** Vanilla 1.12 stores no cast times anywhere
-> readable (the cast bar is Lua-driven off `SPELLCAST_START`), and it
-> tracks regular casts for nobody but you — other units' casts exist
-> only as transient animation visuals. So `UnitCastingInfo(otherUnit)`
-> returns `nil`. We self-track the player's cast on a per-frame tick
-> (`VAR_CURRENT_CAST_SPELL`), stamping `startTimeMs = now` and
-> `endTimeMs = now + base cast time`. Instant casts return `nil` (no
-> cast bar). See [`UnitChannelInfo`](#unitchannelinfounit--channelinfo)
-> for channels, which *are* visible on other units.
+> **Works for any unit.** Vanilla 1.12 stores no cast times on the
+> CGUnit (the cast bar is Lua-driven off `SPELLCAST_START`), so we
+> source them two ways: the **local player** is self-tracked on a
+> per-frame tick (`VAR_CURRENT_CAST_SPELL`, stamping `startTimeMs = now`,
+> `endTimeMs = now + effective cast time`); **other units** come from a
+> co-hook on `SMSG_SPELL_START` (`Spell::Cast`), the one packet carrying
+> another unit's cast with a server-authoritative cast time, cached per
+> caster GUID. So `C_Spell.UnitCastingInfo("target")` now backs
+> enemy/target/focus/nameplate cast bars. Instant casts return `nil` (no
+> cast bar). Best-effort for remote units, in three ways: only casts that
+> began while the unit was in range are seen; since 1.12 has no per-unit
+> interrupt packet to hook, an *interrupted* remote cast lingers until its
+> computed `endTimeMs` rather than clearing instantly; and the remote
+> `startTimeMs`/`endTimeMs` are shifted later by roughly your latency.
+> (1.12's `SMSG_SPELL_START` carries only a single `castTime`, so we stamp
+> `start = now, end = now + castTime` on receipt. 3.3.5+ avoids the skew
+> because its packet carries *both* total and remaining cast time and
+> back-dates `start = now − elapsed`; the 1.12 packet has no field to
+> recover `elapsed` from.) The **local player is unaffected** by all of
+> this — its cast is detected client-side at the moment of cast, no packet
+> involved.
 >
 > `isTradeskill` is real — the spell's `SPELL_ATTR_TRADESPELL` flag, so
 > profession recipe casts (smelting, cooking/enchanting recipes, …)
@@ -7799,30 +8173,34 @@ so progress is `(GetTime()*1000 - startTimeMs) / (endTimeMs - startTimeMs)`.
 > `castID`/`castBarID` = `nil`, `notInterruptible` = `false`,
 > `delayTimeMs` = `0`.

-### `UnitChannelInfo(unit)` / `ChannelInfo()`
+### `C_Spell.UnitChannelInfo(unit)` / `C_Spell.ChannelInfo()`

 Returns the unit's in-progress **channel**, or `nil` if it isn't
-channeling. `ChannelInfo()` is `UnitChannelInfo("player")` without the
-token lookup.
+channeling. `C_Spell.ChannelInfo()` is `C_Spell.UnitChannelInfo("player")`
+without the token lookup. (Under `C_Spell` rather than the global name
+for the same reason as
+[`C_Spell.UnitCastingInfo`](#c_spellunitcastinginfounit--c_spellcastinginfo).)

 ```
 name, displayName, textureID, startTimeMs, endTimeMs, isTradeskill,
-  notInterruptible, spellID = UnitChannelInfo(unit)
+  notInterruptible, spellID = C_Spell.UnitChannelInfo(unit)
 ```

 ```lua
-ChannelInfo()
+C_Spell.ChannelInfo()
 -- "Blizzard", "Blizzard", "Interface\\Icons\\Spell_Frost_IceStorm",
 --  907894314, 907902314, false, false, 10187
 ```

-Unlike casts, the channeled spellID **is** broadcast for every unit
-(`UNIT_FIELD_CHANNEL_SPELL`), so `UnitChannelInfo("target")` works on
-other units — returning `name`/`displayName`/`textureID`/`spellID` with
-**`nil` start/end times** (we only track the local player's channel
-start). For the player, the full timing is present
-(`endTimeMs - startTimeMs` = channel duration). Same placeholder fields
-as `UnitCastingInfo`.
+The channeled spellID **is** broadcast for every unit
+(`UNIT_FIELD_CHANNEL_SPELL`), so `C_Spell.UnitChannelInfo("target")` works
+on other units. Timing now comes from the same `SMSG_SPELL_START` co-hook
+as casts: when we observed the channel begin, the remote unit returns full
+**start/end times** (validated against the live `UNIT_FIELD_CHANNEL_SPELL`
+so a stale cache entry never applies to a different/ended channel);
+otherwise it falls back to `name`/`displayName`/`textureID`/`spellID` with
+**`nil` times**. The player path is unchanged (full timing). Same
+placeholder fields as `C_Spell.UnitCastingInfo`.

 ## SpellBook

@@ -8069,7 +8447,7 @@ This is distinct from spell channeling: the function fires for
 *participants* who clicked the portal, not the warlock who cast
 Ritual of Summoning. Vanilla has no Lua surface for this state —
 the engine's `SPELLCAST_CHANNEL_*` events don't fire and
-`CastingInfo()` returns nothing — so addons that want to react to
+`C_Spell.CastingInfo()` returns nothing — so addons that want to react to
 the player being committed to a ritual (e.g. suppress autorun
 toggles, hide nameplate clicks, warn before movement) have no other
 way to detect it.
@@ -9095,21 +9473,79 @@ selects.
 | `dispelName` | string | `"Magic"` / `"Curse"` / `"Disease"` / `"Poison"` (from `SpellDispelType.dbc`), or `""` if non-dispellable |
 | `isHelpful` | boolean | true for slot < 32 |
 | `isHarmful` | boolean | true for slot >= 32 |
-| `duration` | number | base applied duration in seconds, looked up via `Spell.dbc → SpellDuration.dbc` with level scaling. Talent / glyph duration extensions (Improved PW:F, etc.) aren't reflected here — those are baked into `expirationTime` on the caster's side. Returns 0 for spells flagged "no duration" (passives, paladin auras, infinite buffs) |
-| `expirationTime` | number | populated for `unit == "player"` (read from the engine's player-buff table at `0x00BC6040`; same data `GetPlayerBuffTimeLeft` returns). Always `0` for all other units — vanilla server only broadcasts cast/duration for the local player's own auras. `expirationTime - GetTime()` gives the true remaining time (including any talent extensions) |
+| `duration` | number | applied duration in seconds. When the aura's cast was observed (in the `Aura::Source` cache), this is the caster-modified duration — talent/glyph extensions like Improved Shadow Word: Pain included — so it stays consistent with `expirationTime` (`remaining ≤ duration`). On a cache miss it falls back to the base `Spell.dbc → SpellDuration.dbc` value with level scaling. Returns 0 for spells flagged "no duration" (passives, paladin auras, infinite buffs) |
+| `expirationTime` | number | for `unit == "player"`, read from the engine's player-buff table at `0x00BC6040` (same data `GetPlayerBuffTimeLeft` returns). For any other unit, taken from the `Aura::Source` cache (cast time + duration captured from `SMSG_SPELL_GO`; see below). `0` when neither source has it. `expirationTime - GetTime()` gives the true remaining time |
+| `sourceUnit` | string | unit token of the caster (`"player"`, `"raid7"`, `"nameplate1"`, …), resolved from the `Aura::Source` cache. `nil` if the cast wasn't observed or the caster maps to no current token |
+| `sourceGUID` | string | caster's `"0x…"` GUID string from the same cache. **ClassicAPI extension — not a retail `AuraData` field.** Set whenever a caster is known, including when `sourceUnit` is `nil` (caster left token range). Stable for the session, unlike the volatile nameplate token; doubles as a unit token under SuperWoW. `nil` on a cache miss |
 | `charges` / `maxCharges` | number | always `0` — vanilla has stacks, not charges |
 | `timeMod` | number | always `1` — vanilla has no haste-affected auras |
 | `isStealable`, `isBossAura`, `isFromPlayerOrPlayerPet`, `isNameplateOnly`, `nameplateShowAll`, `nameplateShowPersonal`, `canApplyAura`, `shouldConsolidate`, `isRaid` | boolean | always `false` — modern UI concepts vanilla doesn't have |
-| `sourceUnit`, `auraInstanceID`, `points` | (absent) | omitted from the table — Lua read yields nil, matching modern semantics for "field doesn't apply" |
+| `auraInstanceID`, `points` | (absent) | omitted from the table — Lua read yields nil, matching modern semantics for "field doesn't apply" |

 ### Filter parsing

 The optional `filter` string is a pipe-separated set of upper-case
 tokens, matching modern syntax (`"HELPFUL"`, `"HARMFUL"`,
-`"HELPFUL|PLAYER"`, etc.). Only `HELPFUL` (default) and `HARMFUL`
-are honored on vanilla; other tokens (`PLAYER` / `RAID` /
-`CANCELABLE` / `INCLUDE_NAME_PLATE_ONLY`) are accepted but no-op —
-they'd need source-GUID tracking or systems vanilla doesn't have.
+`"HELPFUL|PLAYER"`, etc.). Honored on vanilla:
+
+- **`HELPFUL`** (default) / **`HARMFUL`** — pick the buff or debuff range.
+  In `GetUnitAuras`, supplying neither returns both ranges.
+- **`PLAYER`** — restrict to auras the local player cast, via the
+  `Aura::Source` caster cache (`sourceGUID == ` player GUID). Combines with
+  the range tokens (`"HARMFUL|PLAYER"` = your debuffs only). Because the
+  caster is best-effort, an aura whose cast we didn't observe is treated as
+  not-player-cast and excluded — so `PLAYER` can under-report auras that
+  predate login.
+
+Other tokens (`RAID` / `CANCELABLE` / `INCLUDE_NAME_PLATE_ONLY`) are
+accepted but no-op — they need engine systems (raid-dispel relevance,
+nameplate visibility flags) vanilla doesn't have.
+
+### Caster & timing (`Aura::Source`)
+
+`sourceUnit`, `sourceGUID`, and non-player `expirationTime` come from a
+client-side cache that vanilla itself can't provide: the unit aura array
+stores only spell IDs — never the caster, and no cast/expiration timing for
+anyone but the local player. `Aura::Source` fills the gap by co-hooking
+three engine functions and caching `(targetGuid, spellId) → { casterGuid,
+expirationMs, durationMs }`; `Push` keys into it by the unit's GUID + the
+aura's spell ID.
+
+- **`SpellGo`** (`FUN_SPELL_GO`, `0x006E7A70`) — the cast packet, the only
+  place the client sees an aura's **caster** + a server-authoritative,
+  caster-modified duration. Fills `sourceUnit`/`sourceGUID` + timing for
+  directly-cast auras.
+- **`OnAuraAdded`** (`0x006123F0`) — fires when any aura first occupies a
+  slot, including proc/triggered auras that emit no `SMSG_SPELL_GO` (Shadow
+  Weaving etc.). Stamps `expirationMs = now + base duration` (no caster).
+- **`OnAuraStacksChanged`** (`0x00612450`) — fires when an existing aura's
+  stack count changes; re-stamps expiration so a climbing stacking debuff
+  (e.g. Shadow Weaving 1→5) refreshes.
+
+Application hooks never overwrite an entry `SpellGo` already owns, so a
+directly-cast aura keeps its talented timing + caster regardless of hook
+order.
+
+Implications:
+
+- **Best-effort.** Only auras observed *after* login carry data; auras
+  already up when you logged in leave the defaults (`sourceUnit`/`sourceGUID`
+  nil, non-player `expirationTime` 0).
+- **Max-stack refresh is a blind spot.** When a stacking debuff is refreshed
+  at *max* stacks (e.g. Shadow Weaving 5→5), no client-visible aura field
+  changes (spellID, stacks, flags, level all identical), so the server sends
+  no UpdateField and the engine fires no callback — there is no packet to
+  hook (verified: the stack-change dispatcher `FUN_00604ea0` calls
+  `OnAuraStacksChanged` unconditionally, so its silence proves nothing
+  arrived). The countdown therefore runs to 0 and the entry evicts; once
+  evicted, `expirationTime` falls back to 0 (unknown) while the aura is still
+  shown. Climbing stacks and single-stack refreshes (re-cast → fresh
+  `SpellGo`) are unaffected.
+- **No nampower dependency.** We parse the engine functions ourselves;
+  nampower (which hooks the same three) need not be loaded — when it is, we
+  co-hook the sites.
+- Entries are evicted once their timed aura elapses, so the cache stays
+  bounded; infinite-duration auras persist until overwritten under load.

 ### `C_UnitAuras.GetAuraDataByIndex(unit, index [, filter])`

@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Common.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 namespace Common {
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Common.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -253,6 +253,32 @@ enum Offsets {
    FUN_FIND_CVAR = 0x0063DEC0,
    OFF_CVAR_VALUE_STR = 0x20,

+    // Internal CVar registrar — what `Script_RegisterCVar` calls after a
+    // `FindCVar` miss (the call at `0x00488B8A`). `__fastcall`; ECX=name,
+    // EDX is a second string slot the script path leaves 0, then six
+    // stack args: flags, defaultValue, changeCallback, categoryId,
+    // hiddenBool, userData. Dedups by name (re-registering OR-merges
+    // flags + updates the callback), so it's idempotent across `/reload`.
+    // The new-cvar branch forces flags bit 0 on (`puVar3[7] = flags | 1`),
+    // which is what makes script-registered cvars persist to Config.wtf.
+    // See `CVar::Factory` for the wrapper.
+    FUN_REGISTER_CVAR = 0x0063DB90,
+    // Internal "apply value" — `__fastcall(cvar /*ecx*/, value, a3, a4,
+    // a5, a6)`, called by `Script_SetCVar` at `0x00488CA8`. Fires the
+    // change callback at `[cvar+0xBC]` as
+    // `char __fastcall(cvar /*ecx*/, prevValue /*edx*/, newValue /*stack*/,
+    // userData /*stack*/)` — return 0 to REJECT the change, nonzero to
+    // accept (verified at `0x0063DF7D`).
+    FUN_SET_CVAR_VALUE = 0x0063DF50,
+    // CVar struct fields (beyond the value string at +0x20 above).
+    OFF_CVAR_FLAGS = 0x1C,
+    OFF_CVAR_CALLBACK = 0xBC,
+    OFF_CVAR_USERDATA = 0xC0,
+    // The categoryId the script path passes as the registrar's 6th stack
+    // arg (the `PUSH 9` in `Script_RegisterCVar`). Cosmetic console
+    // grouping; we reuse it so our cvars behave like script-registered ones.
+    CVAR_SCRIPT_CATEGORY = 9,
+
    // Engine-side Lua C functions backing the in-game CVar globals.
    // Standard `int __fastcall(void *L)` ABI. We don't register them
    // ourselves in-game — the engine already does at boot — but we
@@ -682,6 +708,69 @@ enum Offsets {
    OFF_SPELLDURATION_PER_LEVEL_MS = 0x08,
    OFF_SPELLDURATION_MAX_MS = 0x0C,

+    // `SMSG_SPELL_GO` inner handler — `void __fastcall(uint64_t *itemGUID,
+    // uint64_t *casterGUID, uint32_t spellId, CDataStore *packet)`. The
+    // engine has already decoded item/caster/spell into args; the packet
+    // read cursor sits at the post-header body (castFlags, hit/missed
+    // target lists, target mask). This is the ONLY place the client sees
+    // an aura's *caster* — the unit aura array stores spell IDs but never
+    // who applied them. `Aura::Source` co-hooks this (alongside nampower,
+    // which detours the same function) to cache `(targetGuid, spellId) →
+    // casterGuid` for `C_UnitAuras` sourceUnit + non-player expiration.
+    // Packet layout mirrored from nampower's SpellGoHook (verified on the
+    // same Octo/Turtle 1.12.1 client). Per-cast frequency, not per-frame.
+    FUN_SPELL_GO = 0x006E7A70,
+
+    // SMSG packet handler that processes `SMSG_SPELL_START` (opcode
+    // `0x131`) among others — `int __fastcall(uint32_t unk, uint32_t
+    // opCode, uint32_t unk2, CDataStore *packet)`. For `0x131` the body is
+    // `itemGuid(packed), casterGuid(packed), spellId(u32), castFlags(u16),
+    // castTime(u32), targetMask, …`. This is the only place the client sees
+    // *another* unit's cast with a server-authoritative cast time, so
+    // `Spell::Cast` co-hooks it (gated on `opCode == 0x131`) to back
+    // remote-unit `UnitCastingInfo` / `UnitChannelInfo`. Mirrored from
+    // nampower's SpellStartHandlerHook.
+    FUN_SPELL_START_HANDLER = 0x006E7640,
+
+    // `SMSG_SPELL_DELAYED` handler — `int __stdcall(uint32_t *opCode,
+    // CDataStore *packet)`. Body: `guid(u64), delayMs(u32)`. The server
+    // only sends this to the affected caster, so in practice it's always
+    // the local player's cast pushback (taking damage mid-cast). `Spell::
+    // Cast` co-hooks it to extend the tracked cast's end time so the bar
+    // reflects pushback. Mirrored from nampower's SpellDelayedHook.
+    FUN_SPELL_DELAYED = 0x006E74F0,
+
+    // `CGUnit_C::OnAuraAdded` — `__thiscall void(CGUnit *unit, uint32_t
+    // slot, uint32_t spellId)` (i.e. `__fastcall(unit /*ecx*/, edx_unused,
+    // slot, spellId)`). Fires for EVERY aura that lands on a tracked unit,
+    // including proc/triggered auras that never produce an `SMSG_SPELL_GO`
+    // (Shadow Weaving, etc.). `Aura::Source` co-hooks it to stamp
+    // expiration for those — it carries no caster, so it fills timing only
+    // and never overwrites an entry `SpellGo` already owns. Per-aura-change
+    // frequency. nampower hooks the same function (its BUFF/DEBUFF events).
+    FUN_ON_AURA_ADDED = 0x006123F0,
+
+    // `CGUnit_C::OnAuraStacksChanged` — `__thiscall void(CGUnit *unit, int
+    // slot, uint8_t stackCount)` (`__fastcall(unit, edx_unused, slot,
+    // stackCount)`). Fires when an existing aura's stack count changes
+    // without a fresh add — e.g. Shadow Weaving climbing 2→3. The slot's
+    // spellID is read from the unit aura array (`OnAuraAdded` gets it as an
+    // arg; here only the slot is given). `Aura::Source` co-hooks it to
+    // re-stamp expiration so stacking-DoT refreshes are picked up.
+    FUN_ON_AURA_STACKS_CHANGED = 0x00612450,
+
+    // `CGUnit_C::OnAuraRemoved` — same ABI as `OnAuraAdded`
+    // (`__fastcall(unit /*ecx*/, edx_unused, slot, spellId)`; the disassembly
+    // of the diff dispatcher `FUN_00604d00` at the call site `0x00604dc4`
+    // shows `ECX = unit`, stack `[slot, spellId]`). The sibling of
+    // `OnAuraAdded`: `FUN_00604d00` fires this when a descriptor aura slot
+    // goes from occupied to empty — a genuine removal (fell off, dispelled,
+    // or replaced by a higher rank, which fires Removed(old)+Added(new)).
+    // `Aura::Source` co-hooks it to EVICT the cached entry so the
+    // `GetAuraDataByIndex` fallback can't resurrect a superseded/dispelled
+    // aura that's still inside its computed duration window.
+    FUN_ON_AURA_REMOVED = 0x00612320,
+
    // CGPlayer-side sub-struct, allocated for any player-controlled
    // unit (local self, target, party, raid, inspect targets — all of
    // them). Holds player-specific data that's *not* in the broadcast
@@ -1364,6 +1453,17 @@ enum Offsets {
    OFF_ITEMSUBCLASS_RECORD_STRIDE = 0x74,
    OFF_ITEMSUBCLASS_NAME = 0x28,
    OFF_ITEMSUBCLASS_DISPLAY_NAME = 0x4C,
+    // record +0x00 = classID, +0x04 = subClassID (the compound key the
+    // linear scan matches on). Flags field at +0x10; bit 0x200 marks the
+    // subclasses whose items display by inventory slot rather than by
+    // subclass name — set on exactly the armor material types (Misc / Cloth
+    // / Leather / Mail / Plate), clear on weapons, shields, librams, etc.
+    // This is `C_Item.GetItemSubClassInfo`'s `subClassUsesInvType` return.
+    // Derived by dumping ItemSubClass.dbc (see docs/DBCs.md dump oracle).
+    OFF_ITEMSUBCLASS_CLASS_ID = 0x00,
+    OFF_ITEMSUBCLASS_SUBCLASS_ID = 0x04,
+    OFF_ITEMSUBCLASS_FLAGS = 0x10,
+    ITEMSUBCLASS_FLAG_USES_INVTYPE = 0x200,

    // ItemDisplayInfo.dbc — standard layout. Icon path char* at record +0x14
    // (per the helper at 0x005D88B0 that Script_GetItemInfo uses).
@@ -1588,6 +1688,19 @@ enum Offsets {
    OFF_UNIT_DESCRIPTOR_CLASS_BYTE = 0x79,
    OFF_UNIT_DESCRIPTOR_SEX_BYTE = 0x7A,

+    // The local player's UNIT_FIELD_BYTES_0 race/class/sex bytes, mirrored
+    // into a login-time global that is populated at character-enter —
+    // BEFORE the in-world CGUnit/descriptor exists. Script_UnitClass
+    // (0x00518350) and Script_UnitRace special-case the literal "player"
+    // token to read these (Script_UnitClass calls FUN_005abde0 →
+    // `return DAT_00c27e81`), which is why UnitClass("player") resolves at
+    // addon-load while a descriptor read returns nil until the player
+    // object spawns. Getters: race FUN_005abdd0, class FUN_005abde0,
+    // sex FUN_005abdf0.
+    VAR_PLAYER_RACE_BYTE = 0x00C27E80,
+    VAR_PLAYER_CLASS_BYTE = 0x00C27E81,
+    VAR_PLAYER_SEX_BYTE = 0x00C27E82,
+
    // SkillLineAbility.dbc — maps each (class, race) pair to its
    // learnable spell list with skill-rank gating. Indexed by record
    // ID; reads via the standard `records[id]` pattern. Used by
@@ -1982,6 +2095,68 @@ enum Offsets {
    FUN_DBCACHE_QUEST_GET_RECORD = 0x00562A40,
    VAR_QUEST_LOG_SELECTED_QUEST_ID = 0x00BB7480,

+    // Creature cache (creaturecache.wdb, SMSG_CREATURE_QUERY_RESPONSE).
+    // One instance of the generic client query-cache class; constructed
+    // by the cache factory (FUN_00554b40 -> FUN_00556060 with sig
+    // 'BOMW', "creaturecache.wdb", recordSize 0x60).
+    VAR_CREATURE_CACHE = 0x00C0E354,
+    // Creature-cache `_GetRecord` — `__thiscall(cache, id, const u64 *guid,
+    // void *callback, void *userData, char dedup)`. Returns the data
+    // block (entry+0x18) when loaded; with `callback==0` it only peeks
+    // (no query), with a non-null callback it fires the network query on
+    // a miss. Class-specific (reads the loaded flag at entry+0x50);
+    // gameobjects are a sibling class with a different layout and their
+    // own `_GetRecord` (FUN_GAMEOBJECT_GET_RECORD). Verified via
+    // FUN_00604600 (`FUN_00556aa0(creatureID, &guid, cb, 0, 0)`).
+    FUN_CREATURE_GET_RECORD = 0x00556AA0,
+    // Creature-cache response parser — `__thiscall(cache, packetReader,
+    // flag)`. Fills the entry data block, sets the loaded flag (entry+0x50),
+    // and walks the entry's pending-callback list. The creature SMSG
+    // handler `FUN_005550E0` calls it with ecx=the creature cache.
+    // `Cache::QueryLoad` hooks it to fire CREATURE_DATA_LOAD_RESULT. The
+    // item/quest caches have their own parsers, so it's conflict-free.
+    FUN_CREATURE_QUERY_RESPONSE = 0x00556E20,
+    // Creature-query record field offsets, within the data block returned
+    // by FUN_CREATURE_GET_RECORD. Anchored by rank@+0x20 (read by the
+    // classification helper FUN_00605620 as `[block+0x20]`) and the
+    // wire/WDB field order (Name[4], SubName, typeFlags, type, family,
+    // rank, unk, petSpellDataId, displayId), cross-checked against real
+    // creaturecache.wdb rows (Misthoof Stag 61332 -> type 1; Nordrassil
+    // Nymph 61582 -> type 7, rank 1). Strings are char* (the fixed 0x60
+    // block holds pointers, not the WDB's inline strings).
+    OFF_CREATURE_NAME = 0x00,      // char *Name[4]; [0] is the primary name
+    OFF_CREATURE_SUBNAME = 0x10,   // char *SubName (title); "" if none
+    OFF_CREATURE_TYPE = 0x18,      // CreatureType (1=Beast, 7=Humanoid, ...)
+    OFF_CREATURE_FAMILY = 0x1C,    // CreatureFamily
+    OFF_CREATURE_RANK = 0x20,      // 0=normal,1=elite,2=rareelite,3=worldboss,4=rare
+    OFF_CREATURE_DISPLAYID = 0x2C, // creature model display ID
+
+    // GameObject cache (gameobjectcache.wdb, SMSG_GAMEOBJECT_QUERY_RESPONSE).
+    // Sibling cache class to creature (constructed by FUN_00554B90 ->
+    // FUN_00557bd0, sig 'BOGW', recordSize 0x5E) — same struct shape but a
+    // different vtable (0x0080913C) and a LARGER entry (loaded flag at
+    // entry+0x98, not +0x50), so it has its own `_GetRecord` and parser.
+    VAR_GAMEOBJECT_CACHE = 0x00C0E318,
+    // GO `_GetRecord`, same signature as the creature one. Verified via
+    // FUN_0062dc10 (`FUN_00558560(goEntry, &guid, 0,0,0)` then reads the
+    // GO name at `[block+0x08]`).
+    FUN_GAMEOBJECT_GET_RECORD = 0x00558560,
+    // GO response parser — `__thiscall(cache, packetReader, flag)`. The GO
+    // SMSG handler `FUN_00555100` calls it with ecx=the GO cache. Distinct
+    // from the creature parser (sets loaded flag at entry+0x98), so
+    // `Cache::QueryLoad` hooks it separately to fire GAMEOBJECT_DATA_LOAD_RESULT.
+    FUN_GAMEOBJECT_QUERY_RESPONSE = 0x005588E0,
+    // GO-query record field offsets, within the data block returned by
+    // FUN_GAMEOBJECT_GET_RECORD. Wire/WDB order: type, displayId, Name[4],
+    // then a 24-int data[] array. name@+0x08 verified (FUN_0062dc10 reads
+    // `[block+0x08]` as the name); type@+0x00 / displayId@+0x04 follow from
+    // the field order, cross-checked against real gameobjectcache.wdb rows
+    // (Windrunner type 15 displayId 7087; Mesa Elevator 47297 type 11
+    // displayId 360).
+    OFF_GAMEOBJECT_TYPE = 0x00,      // GameObjectType (0=door,3=chest,…)
+    OFF_GAMEOBJECT_DISPLAYID = 0x04, // model display ID
+    OFF_GAMEOBJECT_NAME = 0x08,      // char *Name[4]; [0] is the primary name
+
    // Action bar slot table — `uint[120]` (max slot index `< 0x78`).
    // Each entry is a packed action descriptor; top 4 bits are the type
    // tag, low 28 bits are the payload. Tags:
@@ -2260,6 +2435,18 @@ enum Offsets {
    // `FUN_006E3D10`. Non-zero means "the cast bar is showing this
    // spell"; cleared to 0 when the cast finishes or is cancelled.
    VAR_CURRENT_CAST_SPELL = 0x00CECA88,
+    // The cast-start state writer — `__fastcall(int spellID, int
+    // targetState)`. Sets `VAR_CURRENT_CAST_SPELL` (pushing any current
+    // spell into `VAR_QUEUED_CAST_SPELL`; `spellID == 0` restores the queued
+    // one). `Spell::Cast` co-hooks it for lag-free, client-side detection of
+    // NORMAL player casts (stamps from the spellID arg before the original).
+    // It does NOT fire for a chained same-spell recast: the caller
+    // `Spell_C_CastSpell` (`0x006E4B60`) short-circuits at `spellID ==
+    // VAR_CURRENT_CAST_SPELL` *before* reaching here, so those never run the
+    // client cast path — they're caught by the `SMSG_SPELL_START` backstop
+    // instead. nampower hooks the higher Spell_C_CastSpell, not this inner
+    // writer, so contention is low.
+    FUN_CAST_START_SET = 0x006E4AD0,
    // Previous / queued cast — holds the spellID that was active
    // before the latest one superseded it (mid-GCD queueing in
    // vanilla). When the current cast ends, `FUN_006E4AD0(0, ...)`
@@ -2451,6 +2638,22 @@ enum Offsets {
    OFF_SPELLITEMENCHANT_ARG = 0x28,           // int EffectArg[3]
    OFF_SPELLITEMENCHANT_NAME = 0x34,          // char *name[8], locale-indexed

+    // ItemRandomProperties.dbc — the table a random-suffix ID (the third
+    // field of an `item:id:enchant:suffix:unique` link) indexes to get
+    // the SpellItemEnchantment IDs that apply the "of the Bear"-style
+    // bonus. Standard 5-DWORD DBC instance at 0x00C0DBCC; records-ptr at
+    // +0x08, count at +0x0C (see docs/DBCs.md). Verified by parsing the
+    // on-disk ItemRandomProperties.dbc: 16-field / 0x40 records, field 0
+    // = ID, field 1 = internal name string, and the enchant IDs occupy
+    // fields 2..6 (offset +0x08, five contiguous u32 slots — only the
+    // first few are used; the rest are 0). Field 7 duplicates the name
+    // string offset, so it is NOT an enchant slot — do not read past
+    // slot 5.
+    VAR_ITEMRANDOMPROP_RECORDS = 0x00C0DBD4,   // ItemRandomPropertiesRecord *records[suffixID]
+    VAR_ITEMRANDOMPROP_COUNT = 0x00C0DBD8,     // max suffix ID
+    OFF_ITEMRANDOMPROP_ENCHANT = 0x08,         // u32 Enchantment[5]
+    ITEMRANDOMPROP_ENCHANT_SLOT_COUNT = 5,
+
    // Spell.dbc School field — 0-based integer at record +0x04.
    // Verified empirically against Fireball (133) → School=2 (Fire)
    // and Frostbolt (116) → School=4 (Frost) on Octo 1.12.1. Vanilla
@@ -3899,6 +4102,15 @@ enum Offsets {
    OFF_SPELL_RECORD_EFFECT_MISC_VALUE = 0x1A8,       // int32[3]
    SPELL_RECORD_EFFECT_COUNT = 3,

+    // EffectBasePoints[3] — the base magnitude of each effect, stored as
+    // (value - 1) for the fixed-die spells that back item stats (the
+    // engine adds a 1..dieSides roll; dieSides == 1 makes it value = base
+    // + 1). Verified empirically: the "Increased Intellect 01/02/03"
+    // random-property spells (7468/7469/7470) hold base 0/1/2 for the
+    // +1/+2/+3 tiers. Read by Item::Stats when resolving random-suffix
+    // stat auras. Parallel [3] array to APPLY_AURA_NAME / MISC_VALUE.
+    OFF_SPELL_RECORD_EFFECT_BASE_POINTS = 0x130,      // int32[3]
+
    // Per-effect EffectRadiusIndex[3] → SpellRadius.dbc. Verified by
    // FUN_006e6350, which reads spellRec[+0x160] (effect 0) and
    // spellRec[+0x164] (effect 1) as radius indices. 0 = effect has no
@@ -4068,6 +4280,29 @@ enum Offsets {
    VAR_GLUE_LOGIN_READY1 = 0x00B41DFC,
    VAR_GLUE_LOGIN_READY2 = 0x00B41E04,
    VAR_GLUE_LOGIN_INPROGRESS = 0x00B41DA0,
+    // The same `VAR_GLUE_LOGIN_INPROGRESS` global doubles as a glue
+    // state-code: `FUN_GLUE_ENTER_WORLD` sets it to `8` ("entering world")
+    // on a successful commit, which `Unit::Identity`'s enter-world co-hook
+    // gates on (the rename / char-locked bail paths return before it).
+    GLUE_STATE_ENTERING_WORLD = 8,
+
+    // `FUN_0046B500` — the enter-world worker behind `Script_EnterWorld` (the
+    // glue "Enter World" button: `Script_EnterWorld` is just `call this; ret`).
+    // Computes the selected character's struct into VAR_GLUE_SELECTED_CHAR and,
+    // on success, sets VAR_GLUE_LOGIN_INPROGRESS = 8. `Unit::Identity` co-hooks
+    // it to capture the selected character's GUID *before* the engine creates
+    // the in-world player object — so `UnitGUID("player")` / `PlayerGuid()`
+    // answer from addon-load time instead of returning nil/0 until the
+    // SMSG_UPDATE_OBJECT that populates the player object (≈PLAYER_LOGIN).
+    FUN_GLUE_ENTER_WORLD = 0x0046B500,
+
+    // Selected-character struct pointer (glue): char-array base +
+    // selectedIndex*0x120, written by FUN_GLUE_ENTER_WORLD. The character's
+    // 64-bit login GUID is at offset 0x00 (name at +0x08, race +0x100, class
+    // +0x101, level +0x108 — verified against `Script_GetCharacterInfo` at
+    // `0x004732A0`). Entries are filled from SMSG_CHAR_ENUM.
+    VAR_GLUE_SELECTED_CHAR = 0x00B41DF4,
+    OFF_GLUE_CHAR_GUID = 0x00,

    // Cursor state — single global type-tag at VAR_CURSOR_TYPE
    // dispatches reads through one of several payload slots depending
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `GetActionInfo(slot)` — modern-WoW-style action descriptor lookup.
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // Embedded `!!!ClassicAPI` addon fallback. When the user doesn't have
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_AddOns.*` convenience wrappers. Modern WoW splits the legacy
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `CLASSIC_API_VERSION` global — a single integer addons can read for
@@ -1,12 +1,12 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.

 // `C_UnitAuras.*` — modern aura-data namespace. Returns AuraData
 // tables built by `Aura::Data::Push` (see `Data.h`). The fields the
@@ -60,6 +60,13 @@ Data::Filter ParseFilter(const char *filter) {
    return Data::Filter::Helpful;
 }

+// The `PLAYER` filter token restricts results to auras the local player
+// cast. No other modern token contains the substring "PLAYER", so a plain
+// substring test is safe.
+bool HasPlayerFilter(const char *filter) {
+    return filter != nullptr && strstr(filter, "PLAYER") != nullptr;
+}
+
 const char *ArgUnit(void *L, int idx) {
    if (!Game::Lua::IsString(L, idx))
        return nullptr;
@@ -82,14 +89,19 @@ const char *ArgOptString(void *L, int idx) {
 // or nil if no such aura. Used by `GetAuraDataByIndex` and the
 // filter-locked aliases.
 int PushAuraByIndex(void *L, const char *unitToken, int index,
-                    Data::Filter filter) {
+                    Data::Filter filter, bool playerOnly = false) {
    const uint8_t *unit = ResolveUnit(unitToken);
-    const int slot = Data::FindNthSlot(unit, index, filter);
-    if (slot < 0) {
-        Game::Lua::PushNil(L);
+    const int slot = Data::FindNthSlot(unit, index, filter, playerOnly);
+    if (slot >= 0) {
+        Data::Push(L, unit, slot);
        return 1;
    }
-    Data::Push(L, unit, slot);
+    // Descriptor exhausted — an aura the engine dropped from the slot array
+    // (rogue stealth, party range fluctuation) may still be live in the
+    // Aura::Source cache. Surface it after the descriptor entries.
+    if (Data::PushNthCacheFallback(L, unit, index, filter, playerOnly))
+        return 1;
+    Game::Lua::PushNil(L);
    return 1;
 }

@@ -101,7 +113,8 @@ int __fastcall Script_GetAuraDataByIndex(void *L) {
        Game::Lua::PushNil(L);
        return 1;
    }
-    return PushAuraByIndex(L, unit, index, ParseFilter(filterStr));
+    return PushAuraByIndex(L, unit, index, ParseFilter(filterStr),
+                           HasPlayerFilter(filterStr));
 }

 int __fastcall Script_GetBuffDataByIndex(void *L) {
@@ -139,7 +152,8 @@ int __fastcall Script_GetUnitAuraBySpellID(void *L) {
        f = ParseFilter(filterStr);
        fp = &f;
    }
-    const int slot = Data::FindSlotBySpellID(unit, static_cast<uint32_t>(spellID), fp);
+    const int slot = Data::FindSlotBySpellID(unit, static_cast<uint32_t>(spellID),
+                                             fp, HasPlayerFilter(filterStr));
    if (slot < 0) {
        Game::Lua::PushNil(L);
        return 1;
@@ -163,7 +177,8 @@ int __fastcall Script_GetAuraDataBySpellName(void *L) {
        f = ParseFilter(filterStr);
        fp = &f;
    }
-    const int slot = Data::FindSlotBySpellName(unit, spellName, fp);
+    const int slot = Data::FindSlotBySpellName(unit, spellName, fp,
+                                               HasPlayerFilter(filterStr));
    if (slot < 0) {
        Game::Lua::PushNil(L);
        return 1;
@@ -192,7 +207,7 @@ int __fastcall Script_GetPlayerAuraBySpellID(void *L) {
 // sequential keys starting from `nextKey`. Updates `nextKey` so a
 // follow-up call can append to the same outer table.
 void AppendRangeToArray(void *L, const uint8_t *unit, int outerIdx,
-                       Data::Filter filter, int &nextKey) {
+                       Data::Filter filter, int &nextKey, bool playerOnly) {
    const int start = (filter == Data::Filter::Harmful)
                          ? Offsets::UNIT_AURA_BUFF_COUNT
                          : 0;
@@ -202,10 +217,14 @@ void AppendRangeToArray(void *L, const uint8_t *unit, int outerIdx,
    for (int slot = start; slot < end; ++slot) {
        if (!Data::IsSlotPopulated(unit, slot))
            continue;
+        if (playerOnly && !Data::IsPlayerCast(unit, slot))
+            continue;
        Game::Lua::PushNumber(L, static_cast<double>(nextKey++));
        Data::Push(L, unit, slot);
        Game::Lua::SetTable(L, outerIdx);
    }
+    // Append auras the descriptor dropped but Aura::Source still has live.
+    Data::AppendCacheFallbacks(L, unit, filter, playerOnly, outerIdx, nextKey);
 }

 int __fastcall Script_GetUnitAuras(void *L) {
@@ -218,14 +237,19 @@ int __fastcall Script_GetUnitAuras(void *L) {
    if (unit == nullptr)
        return 1;

+    // Range tokens are independent of PLAYER: an explicit HELPFUL/HARMFUL
+    // selects that range, neither selects both. So `"PLAYER"` alone returns
+    // both ranges restricted to player-cast auras (matching retail).
+    const bool playerOnly = HasPlayerFilter(filterStr);
+    const bool hasHelpful = filterStr != nullptr && strstr(filterStr, "HELPFUL") != nullptr;
+    const bool hasHarmful = filterStr != nullptr && strstr(filterStr, "HARMFUL") != nullptr;
+    const bool both = !hasHelpful && !hasHarmful;
+
    int nextKey = 1;
-    if (filterStr == nullptr) {
-        // No filter — return both ranges.
-        AppendRangeToArray(L, unit, 1, Data::Filter::Helpful, nextKey);
-        AppendRangeToArray(L, unit, 1, Data::Filter::Harmful, nextKey);
-    } else {
-        AppendRangeToArray(L, unit, 1, ParseFilter(filterStr), nextKey);
-    }
+    if (hasHelpful || both)
+        AppendRangeToArray(L, unit, 1, Data::Filter::Helpful, nextKey, playerOnly);
+    if (hasHarmful || both)
+        AppendRangeToArray(L, unit, 1, Data::Filter::Harmful, nextKey, playerOnly);
    return 1;
 }

@@ -1,12 +1,12 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.

 // Aura-table primitives. See `Data.h` for the contract; see `Api.cpp`
 // for the Lua-binding surface that consumes these.
@@ -15,7 +15,10 @@

 #include "Game.h"
 #include "Offsets.h"
+#include "aura/Source.h"
 #include "dbc/Lookup.h"
+#include "guid/Guid.h"
+#include "unit/Identity.h"

 #include <cstdint>
 #include <cstring>
@@ -38,6 +41,13 @@ const uint8_t *Descriptor(const uint8_t *unit) {
        unit + Offsets::OFF_CGUNIT_OBJECT_FIELDS);
 }

+// Keys into the `Aura::Source` caster/expiration cache. Thin alias for the
+// shared `Unit::Identity::GuidForObject` so the lookup here and the
+// OnAuraAdded hook in `Aura::Source` read the GUID the same way.
+uint64_t UnitGuid(const uint8_t *unit) {
+    return Unit::Identity::GuidForObject(unit);
+}
+
 const uint8_t *SpellRecord(uint32_t spellID) {
    return DBC::Record(Offsets::VAR_SPELL_RECORDS,
                       Offsets::VAR_SPELL_RECORD_COUNT, spellID);
@@ -219,7 +229,20 @@ bool IsSlotPopulated(const uint8_t *unit, int slot) {
    return IsVisible(SpellRecord(spellID));
 }

-int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter) {
+bool IsPlayerCast(const uint8_t *unit, int slot) {
+    const uint32_t spellID = ReadSpellID(unit, slot);
+    if (spellID == 0)
+        return false;
+    uint64_t casterGuid = 0;
+    uint32_t expMs = 0;
+    uint32_t durMs = 0;
+    if (!Aura::Source::Get(UnitGuid(unit), spellID, &casterGuid, &expMs, &durMs))
+        return false;
+    return casterGuid != 0 && casterGuid == Unit::Identity::PlayerGuid();
+}
+
+int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter,
+                bool playerOnly) {
    if (unit == nullptr || oneBasedIndex < 1)
        return -1;
    const int start = (filter == Filter::Harmful)
@@ -232,6 +255,8 @@ int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter) {
    for (int slot = start; slot < end; ++slot) {
        if (!IsSlotPopulated(unit, slot))
            continue;
+        if (playerOnly && !IsPlayerCast(unit, slot))
+            continue;
        if (++matches == oneBasedIndex)
            return slot;
    }
@@ -239,7 +264,7 @@ int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter) {
 }

 int FindSlotBySpellID(const uint8_t *unit, uint32_t spellID,
-                      const Filter *filter) {
+                      const Filter *filter, bool playerOnly) {
    if (unit == nullptr || spellID == 0)
        return -1;
    const int start = (filter != nullptr && *filter == Filter::Harmful)
@@ -251,14 +276,17 @@ int FindSlotBySpellID(const uint8_t *unit, uint32_t spellID,
    for (int slot = start; slot < end; ++slot) {
        if (!IsSlotPopulated(unit, slot))
            continue;
-        if (ReadSpellID(unit, slot) == spellID)
-            return slot;
+        if (ReadSpellID(unit, slot) != spellID)
+            continue;
+        if (playerOnly && !IsPlayerCast(unit, slot))
+            continue;
+        return slot;
    }
    return -1;
 }

 int FindSlotBySpellName(const uint8_t *unit, const char *spellName,
-                        const Filter *filter) {
+                        const Filter *filter, bool playerOnly) {
    if (unit == nullptr || spellName == nullptr || *spellName == '\0')
        return -1;
    const int start = (filter != nullptr && *filter == Filter::Harmful)
@@ -271,8 +299,11 @@ int FindSlotBySpellName(const uint8_t *unit, const char *spellName,
        if (!IsSlotPopulated(unit, slot))
            continue;
        const char *name = LocalizedSpellName(SpellRecord(ReadSpellID(unit, slot)));
-        if (name != nullptr && std::strcmp(name, spellName) == 0)
-            return slot;
+        if (name == nullptr || std::strcmp(name, spellName) != 0)
+            continue;
+        if (playerOnly && !IsPlayerCast(unit, slot))
+            continue;
+        return slot;
    }
    return -1;
 }
@@ -319,10 +350,13 @@ const char *DispelName(uint32_t dispelTypeID) {
    return (name == nullptr || *name == '\0') ? nullptr : name;
 }

-void Push(void *L, const uint8_t *unit, int slot) {
-    const uint32_t spellID = ReadSpellID(unit, slot);
+// Writes the full modern AuraData table on top of the Lua stack from
+// already-resolved values. Shared by the descriptor path (`Push`) and the
+// cache-fallback path (`PushFromCache`). Net stack effect: +1 (the table).
+static void BuildTable(void *L, uint32_t spellID, int applications,
+                       bool isHelpful, double duration, double expirationTime,
+                       uint64_t casterGuid) {
    const uint8_t *spellRecord = SpellRecord(spellID);
-    const bool isHelpful = slot < Offsets::UNIT_AURA_BUFF_COUNT;

    uint32_t dispelTypeID = 0;
    if (spellRecord != nullptr) {
@@ -339,43 +373,32 @@ void Push(void *L, const uint8_t *unit, int slot) {
    Game::Lua::SetFieldString(L, "name", name);
    Game::Lua::SetFieldString(L, "icon", icon);
    Game::Lua::SetFieldNumber(L, "applications",
-        static_cast<double>(ReadStacks(unit, slot)));
+                              static_cast<double>(applications));
    Game::Lua::SetFieldNumber(L, "spellId", static_cast<double>(spellID));
    Game::Lua::SetFieldString(L, "dispelName", dispel);
    Game::Lua::SetFieldBool(L, "isHelpful", isHelpful);
    Game::Lua::SetFieldBool(L, "isHarmful", !isHelpful);
-
-    // Timing fields. Vanilla doesn't broadcast cast time / duration
-    // for ANY unit's auras except the local player's — for everyone
-    // else (target, party, raid, mouseover) `expirationTime` stays 0
-    // and addons have to track expiry themselves via aura-add events.
-    // For the player we read the engine's `VAR_PLAYER_BUFF_TABLE`
-    // (same data `GetPlayerBuffTimeLeft` returns), which gives us a
-    // real expiration timestamp.
-    //
-    // `duration` comes from Spell.dbc → SpellDuration.dbc with
-    // level scaling. That's the *base* value; talent / glyph
-    // duration-extension modifiers (Improved PW:F, etc.) are
-    // already baked into the expiration timestamp on the
-    // caster's side, so `expirationTime - GetTime()` reflects the
-    // true remaining time even when `duration` doesn't include
-    // the talent boost. We populate `duration` for any unit (the
-    // base value is identical regardless of who's affected); only
-    // `expirationTime` is player-gated.
-    double duration = 0.0;
-    double expirationTime = 0.0;
-    const uint8_t *player = LocalPlayer();
-    if (spellID != 0) {
-        const int unitLevel = (unit != nullptr) ? PlayerLevel(unit) : 0;
-        duration = SpellBaseDurationSeconds(spellID, unitLevel);
-    }
-    if (unit != nullptr && unit == player) {
-        const uint8_t *entry = FindPlayerBuffEntry(spellID);
-        if (entry != nullptr)
-            expirationTime = PlayerBuffExpirationSeconds(entry);
-    }
    Game::Lua::SetFieldNumber(L, "duration", duration);
    Game::Lua::SetFieldNumber(L, "expirationTime", expirationTime);
+
+    if (casterGuid != 0) {
+        // `sourceUnit` is a token (nil when the caster maps to no current
+        // token); `sourceGUID` is the raw "0x..." GUID and is set whenever we
+        // have a caster — a ClassicAPI extension (not in retail AuraData) that
+        // survives the caster leaving token range and doubles as a unit token
+        // under SuperWoW.
+        char tokenBuf[32];
+        char guidBuf[Guid::STRING_SIZE];
+        const char *sourceUnit = Unit::Identity::TokenFromGUID(
+            casterGuid, tokenBuf, sizeof tokenBuf);
+        const char *sourceGUID =
+            Guid::FormatAsString(casterGuid, guidBuf, sizeof guidBuf);
+        if (sourceUnit != nullptr)
+            Game::Lua::SetFieldString(L, "sourceUnit", sourceUnit);
+        if (sourceGUID != nullptr)
+            Game::Lua::SetFieldString(L, "sourceGUID", sourceGUID);
+    }
+
    Game::Lua::SetFieldNumber(L, "charges", 0);
    Game::Lua::SetFieldNumber(L, "maxCharges", 0);
    Game::Lua::SetFieldNumber(L, "timeMod", 1);
@@ -391,10 +414,167 @@ void Push(void *L, const uint8_t *unit, int slot) {
    Game::Lua::SetFieldBool(L, "shouldConsolidate", false);
    Game::Lua::SetFieldBool(L, "isRaid", false);

-    // `sourceUnit`, `auraInstanceID`, `points` deliberately omitted
-    // — modern returns nil for those when they don't apply, and
-    // Lua reading a missing key yields nil, so the table doesn't
-    // need an explicit entry.
+    // `auraInstanceID` and `points` are deliberately omitted — modern returns
+    // nil for those when they don't apply, and Lua reading a missing key
+    // yields nil, so the table doesn't need an explicit entry.
+}
+
+void Push(void *L, const uint8_t *unit, int slot) {
+    const uint32_t spellID = ReadSpellID(unit, slot);
+    const bool isHelpful = slot < Offsets::UNIT_AURA_BUFF_COUNT;
+
+    // Timing fields. Vanilla doesn't broadcast cast time / duration for ANY
+    // unit's auras except the local player's — for everyone else (target,
+    // party, raid, mouseover) `expirationTime` stays 0 unless the
+    // `Aura::Source` cache observed the cast. For the player we read the
+    // engine's `VAR_PLAYER_BUFF_TABLE` (same data `GetPlayerBuffTimeLeft`
+    // returns), which gives a real expiration timestamp.
+    //
+    // `duration` comes from Spell.dbc → SpellDuration.dbc with level scaling
+    // (the *base* value); talent / glyph duration-extension modifiers are
+    // already baked into the expiration timestamp on the caster's side, so
+    // `expirationTime - GetTime()` reflects true remaining time even when the
+    // base `duration` doesn't include the talent boost.
+    double duration = 0.0;
+    double expirationTime = 0.0;
+    uint64_t casterGuid = 0;
+    const uint8_t *player = LocalPlayer();
+    if (spellID != 0) {
+        const int unitLevel = (unit != nullptr) ? PlayerLevel(unit) : 0;
+        duration = SpellBaseDurationSeconds(spellID, unitLevel);
+    }
+    if (unit != nullptr && unit == player) {
+        const uint8_t *entry = FindPlayerBuffEntry(spellID);
+        if (entry != nullptr)
+            expirationTime = PlayerBuffExpirationSeconds(entry);
+    }
+    // Caster + non-player expiration from the SMSG_SPELL_GO cache, captured at
+    // cast time (the descriptor has neither). The player-buff table above is
+    // authoritative for the player's own expiration; the cache fills it for
+    // everyone else. Prefer the applied (caster-modified) duration so it stays
+    // consistent with `expirationTime` — otherwise a talented DoT (Improved
+    // Shadow Word: Pain) would show remaining time exceeding the base.
+    if (spellID != 0) {
+        uint64_t c = 0;
+        uint32_t expMs = 0;
+        uint32_t durMs = 0;
+        if (Aura::Source::Get(UnitGuid(unit), spellID, &c, &expMs, &durMs)) {
+            if (expirationTime == 0.0 && expMs != 0)
+                expirationTime = static_cast<double>(expMs) * 0.001;
+            if (durMs != 0)
+                duration = static_cast<double>(durMs) * 0.001;
+            casterGuid = c;
+        }
+    }
+
+    BuildTable(L, spellID, ReadStacks(unit, slot), isHelpful, duration,
+               expirationTime, casterGuid);
+}
+
+namespace {
+
+// Builds an AuraData table from an `Aura::Source` cache entry — the fallback
+// when the descriptor has dropped the aura's slot. Stack count isn't broadcast
+// in SMSG_SPELL_GO, so `applications` defaults to 1. `duration` uses the
+// applied (caster-modified) ms when known, else the Spell.dbc base.
+void PushFromCache(void *L, const uint8_t *unit,
+                   const Aura::Source::CachedAura &c, bool isHelpful) {
+    double duration = 0.0;
+    if (c.durationMs != 0) {
+        duration = static_cast<double>(c.durationMs) * 0.001;
+    } else {
+        const int unitLevel = (unit != nullptr) ? PlayerLevel(unit) : 0;
+        duration = SpellBaseDurationSeconds(c.spellId, unitLevel);
+    }
+    const double expirationTime =
+        (c.expirationMs != 0) ? static_cast<double>(c.expirationMs) * 0.001 : 0.0;
+    BuildTable(L, c.spellId, 1, isHelpful, duration, expirationTime,
+               c.casterGuid);
+}
+
+// Counts populated descriptor slots matching `filter` (and `playerOnly`).
+int CountSlots(const uint8_t *unit, Filter filter, bool playerOnly) {
+    if (unit == nullptr)
+        return 0;
+    const int start = (filter == Filter::Harmful)
+                          ? Offsets::UNIT_AURA_BUFF_COUNT
+                          : 0;
+    const int end = (filter == Filter::Harmful) ? Offsets::UNIT_AURA_TOTAL
+                                                 : Offsets::UNIT_AURA_BUFF_COUNT;
+    int n = 0;
+    for (int slot = start; slot < end; ++slot) {
+        if (!IsSlotPopulated(unit, slot))
+            continue;
+        if (playerOnly && !IsPlayerCast(unit, slot))
+            continue;
+        ++n;
+    }
+    return n;
+}
+
+constexpr int kFallbackMax = Offsets::UNIT_AURA_TOTAL;
+
+// Whether cache entry `c` should be surfaced as a fallback for `unit` under
+// `filter`/`playerOnly`: it must not already be in a populated descriptor slot
+// (no double-listing the same live aura) and, when player-filtered, must have
+// been cast by us. Superseded / dispelled auras are kept out of the cache by
+// `Aura::Source`'s removal eviction, not filtered here.
+bool FallbackEligible(const uint8_t *unit, const Aura::Source::CachedAura &c,
+                      Filter filter, bool playerOnly) {
+    if (FindSlotBySpellID(unit, c.spellId, &filter, false) >= 0)
+        return false; // still in the descriptor — returned via the slot path
+    if (playerOnly && c.casterGuid != Unit::Identity::PlayerGuid())
+        return false;
+    return true;
+}
+
+} // namespace
+
+bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex,
+                          Filter filter, bool playerOnly) {
+    if (unit == nullptr)
+        return false;
+    // The descriptor held `descCount` matches; the caller already found fewer
+    // than `oneBasedIndex` there, so the cache supplies index
+    // `oneBasedIndex - descCount` (1-based) of the entries it didn't.
+    const int target = oneBasedIndex - CountSlots(unit, filter, playerOnly);
+    if (target < 1)
+        return false;
+    const uint64_t guid = UnitGuid(unit);
+    if (guid == 0)
+        return false;
+    Aura::Source::CachedAura buf[kFallbackMax];
+    const int n = Aura::Source::Enumerate(
+        guid, filter == Filter::Harmful, buf, kFallbackMax);
+    int seen = 0;
+    for (int i = 0; i < n; ++i) {
+        if (!FallbackEligible(unit, buf[i], filter, playerOnly))
+            continue;
+        if (++seen == target) {
+            PushFromCache(L, unit, buf[i], filter == Filter::Helpful);
+            return true;
+        }
+    }
+    return false;
+}
+
+void AppendCacheFallbacks(void *L, const uint8_t *unit, Filter filter,
+                          bool playerOnly, int outerIdx, int &nextKey) {
+    if (unit == nullptr)
+        return;
+    const uint64_t guid = UnitGuid(unit);
+    if (guid == 0)
+        return;
+    Aura::Source::CachedAura buf[kFallbackMax];
+    const int n = Aura::Source::Enumerate(
+        guid, filter == Filter::Harmful, buf, kFallbackMax);
+    for (int i = 0; i < n; ++i) {
+        if (!FallbackEligible(unit, buf[i], filter, playerOnly))
+            continue;
+        Game::Lua::PushNumber(L, static_cast<double>(nextKey++));
+        PushFromCache(L, unit, buf[i], filter == Filter::Helpful);
+        Game::Lua::SetTable(L, outerIdx);
+    }
 }

 } // namespace Aura::Data
@@ -1,12 +1,12 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.

 #pragma once

@@ -47,22 +47,29 @@ bool IsSlotPopulated(const uint8_t *unit, int slot);
 // Finds the absolute slot of the `oneBasedIndex`-th populated aura
 // matching `filter`. Returns -1 if no such aura. Walks
 // 0..UNIT_AURA_BUFF_COUNT-1 for Helpful, UNIT_AURA_BUFF_COUNT..
-// UNIT_AURA_TOTAL-1 for Harmful.
-int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter);
+// UNIT_AURA_TOTAL-1 for Harmful. When `playerOnly` is true, only auras
+// the local player cast (per `IsPlayerCast`) are counted/returned.
+int FindNthSlot(const uint8_t *unit, int oneBasedIndex, Filter filter,
+                bool playerOnly = false);

 // Finds the absolute slot of a populated aura with the given spell
 // ID, optionally restricted to one filter range. `filter` of
 // nullptr searches both ranges (helpful first, then harmful).
-// Returns -1 if not found.
+// `playerOnly` restricts to player-cast auras. Returns -1 if not found.
 int FindSlotBySpellID(const uint8_t *unit, uint32_t spellID,
-                      const Filter *filter);
+                      const Filter *filter, bool playerOnly = false);

 // Finds the absolute slot of a populated aura whose locale-resolved
 // spell name exactly matches `spellName`. Case-sensitive. Otherwise
 // same semantics as `FindSlotBySpellID`. Returns -1 if not found
 // or if `spellName` is null/empty.
 int FindSlotBySpellName(const uint8_t *unit, const char *spellName,
-                        const Filter *filter);
+                        const Filter *filter, bool playerOnly = false);
+
+// True iff the aura at `slot` was cast by the local player, per the
+// `Aura::Source` cache. False on a cache miss (caster unknown) — so a
+// PLAYER-filtered query excludes auras whose cast we didn't observe.
+bool IsPlayerCast(const uint8_t *unit, int slot);

 // Display stack count for the given slot (engine stores stacks-1,
 // we add 1). Returns 0 if the unit is null.
@@ -85,12 +92,18 @@ const char *DispelName(uint32_t dispelTypeID);
 //
 // Populates these fields with real data:
 //   name, icon, applications, spellId, dispelName,
-//   isHelpful, isHarmful, timeMod
+//   isHelpful, isHarmful, timeMod, duration
+//
+// And these from the `Aura::Source` SMSG_SPELL_GO cache when available
+// (else their inapplicable default):
+//   expirationTime (player: engine buff table; others: cache; 0 on miss),
+//   sourceUnit     (caster token from the cache; nil on miss),
+//   sourceGUID     (caster "0x..." GUID string; nil on miss — a ClassicAPI
+//                   extension, not in retail AuraData)
 //
 // And these with vanilla-truthful defaults (matches modern's
 // "field present but inapplicable" semantics):
-//   duration=0, expirationTime=0, charges=0, maxCharges=0,
-//   sourceUnit=nil, auraInstanceID=nil, points=nil,
+//   charges=0, maxCharges=0, auraInstanceID=nil, points=nil,
 //   isStealable=false, isBossAura=false, isFromPlayerOrPlayerPet=false,
 //   isNameplateOnly=false, nameplateShowAll=false,
 //   nameplateShowPersonal=false, canApplyAura=false,
@@ -99,4 +112,24 @@ const char *DispelName(uint32_t dispelTypeID);
 // Net stack effect: +1 (the table).
 void Push(void *L, const uint8_t *unit, int slot);

+// Fallback for the index path when the descriptor has dropped an aura's slot
+// (rogue stealth, party range fluctuation) but it's still active server-side.
+// `oneBasedIndex` is the same index the caller passed to `FindNthSlot`; this
+// resolves it against the `Aura::Source` cache *after* the descriptor matches
+// (so cache entries append after descriptor ones, preserving existing index
+// order). On a hit it pushes the AuraData table and returns true; on a miss it
+// pushes nothing and returns false (caller pushes nil). Only entries whose
+// helpful/harmful classification matches `filter` and that aren't already in a
+// populated descriptor slot are considered.
+bool PushNthCacheFallback(void *L, const uint8_t *unit, int oneBasedIndex,
+                          Filter filter, bool playerOnly = false);
+
+// Appends every eligible `Aura::Source` cache fallback for `unit` matching
+// `filter` into the array table at `outerIdx`, continuing from `nextKey`
+// (updated in place). The bulk-enumeration analog of `PushNthCacheFallback`,
+// for `GetUnitAuras`. Skips entries already present in a populated descriptor
+// slot so it never double-lists.
+void AppendCacheFallbacks(void *L, const uint8_t *unit, Filter filter,
+                          bool playerOnly, int outerIdx, int &nextKey);
+
 } // namespace Aura::Data
@@ -0,0 +1,343 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+
+// See `Source.h` for the contract. This is the backend: a co-hook on
+// `FUN_SPELL_GO` that mirrors nampower's `SpellGoHook` parse to capture the
+// caster + duration of every aura-applying cast, and a small fixed-size
+// cache `Aura::Data::Push` reads from.
+
+#include "Source.h"
+
+#include "Data.h"
+#include "Game.h"
+#include "Offsets.h"
+#include "net/PacketReader.h"
+#include "spell/Lookup.h"
+#include "tick/WorldTick.h"
+#include "unit/Identity.h"
+
+#include <cstdint>
+
+namespace Aura::Source {
+
+namespace {
+
+using Net::CDataStore;
+
+// A cast applies an aura iff any of its three effects names an aura. The
+// EffectApplyAuraName[3] int32 array sits at `+0x16C` (already used by the
+// shapeshift / mechanic-immunity code). Gating on this keeps pure-damage
+// and utility casts out of the cache.
+bool SpellAppliesAura(const uint8_t *spellRecord) {
+    if (spellRecord == nullptr)
+        return false;
+    const auto *auraNames = reinterpret_cast<const int32_t *>(
+        spellRecord + Offsets::OFF_SPELL_RECORD_EFFECT_APPLY_AURA_NAME);
+    for (int i = 0; i < Offsets::SPELL_RECORD_EFFECT_COUNT; ++i) {
+        if (auraNames[i] != 0)
+            return true;
+    }
+    return false;
+}
+
+uint32_t NowMs() {
+    using TickCount_t = uint32_t(__fastcall *)();
+    return reinterpret_cast<TickCount_t>(
+        static_cast<uintptr_t>(Offsets::FUN_OS_TICKCOUNT_MS))();
+}
+
+// Server-authoritative duration (ms). When the local player is the caster
+// we let the engine fold in the player's duration modifiers (skipMod = 0);
+// for any other caster we take the unmodified base (skipMod = 1) since we
+// only have the local player's mod tables. `unit = 0` selects the player
+// mod context per FUN_GET_SPELL_DURATION's signature.
+uint32_t SpellDurationMs(const uint8_t *spellRecord, bool casterIsPlayer) {
+    using GetDuration_t = int(__fastcall *)(const uint8_t *spellRecord,
+                                            int unit, char skipMod);
+    const int ms = reinterpret_cast<GetDuration_t>(
+        static_cast<uintptr_t>(Offsets::FUN_GET_SPELL_DURATION))(
+        spellRecord, 0, casterIsPlayer ? 0 : 1);
+    return ms > 0 ? static_cast<uint32_t>(ms) : 0;
+}
+
+// ---- Cache ---------------------------------------------------------------
+
+// Helpful/harmful classification, recorded from the aura's descriptor slot
+// when it's applied (the only place the buff/debuff split is known). SpellGo
+// gives no slot, so casts we only saw there stay Unknown until/unless an
+// application hook fires for the same aura.
+enum Kind : int8_t { KIND_UNKNOWN = -1, KIND_HELPFUL = 0, KIND_HARMFUL = 1 };
+
+struct Entry {
+    uint64_t targetGuid;
+    uint64_t casterGuid;
+    uint32_t spellId;
+    uint32_t expirationMs; // 0 = infinite / unknown duration
+    uint32_t durationMs;   // applied duration (incl. caster mods); 0 = none
+    int8_t kind;           // Kind; descriptor-slot-derived, KIND_UNKNOWN if only seen via SpellGo
+    bool used;
+};
+
+constexpr int kCacheSize = 256;
+Entry g_cache[kCacheSize];
+int g_writeCursor = 0;
+
+// `fromCast` true: the SpellGo hook — authoritative caster + caster-modified
+// (talented) timing. False: the OnAuraAdded application hook — timing only,
+// no caster, and it must not clobber an entry SpellGo already owns (that
+// would replace talented timing with the unmodified base), so it skips
+// entries that already carry a caster.
+void Store(uint64_t targetGuid, uint32_t spellId, uint64_t casterGuid,
+           uint32_t expirationMs, uint32_t durationMs, bool fromCast,
+           int8_t kind) {
+    if (targetGuid == 0 || spellId == 0)
+        return;
+
+    // Update an existing entry for this exact aura instance.
+    for (auto &e : g_cache) {
+        if (e.used && e.targetGuid == targetGuid && e.spellId == spellId) {
+            // Learn the classification whenever a slot-derived kind arrives —
+            // independent of caster/timing ownership, and never downgrade a
+            // known kind back to unknown.
+            if (kind != KIND_UNKNOWN)
+                e.kind = kind;
+            if (!fromCast && e.casterGuid != 0)
+                return; // SpellGo owns this entry; keep its caster + timing
+            if (casterGuid != 0)
+                e.casterGuid = casterGuid;
+            e.expirationMs = expirationMs;
+            e.durationMs = durationMs;
+            return;
+        }
+    }
+    // Take a free slot, else an expired one, else evict round-robin.
+    const uint32_t now = NowMs();
+    for (auto &e : g_cache) {
+        if (!e.used || (e.expirationMs != 0 && now >= e.expirationMs)) {
+            e = {targetGuid, casterGuid, spellId, expirationMs, durationMs,
+                 kind, true};
+            return;
+        }
+    }
+    Entry &slot = g_cache[g_writeCursor];
+    g_writeCursor = (g_writeCursor + 1) % kCacheSize;
+    slot = {targetGuid, casterGuid, spellId, expirationMs, durationMs, kind,
+            true};
+}
+
+// Evict the entry for an aura the engine reports gone. Keyed by (target,
+// spell) like the rest of the cache. Without this, the GetAuraDataByIndex
+// fallback would keep surfacing a dropped aura until its computed expiry —
+// e.g. a Rank 1 buff replaced by Rank 2 (engine drops Rank 1 from the
+// descriptor) would show as a phantom second aura, or a dispelled buff would
+// linger.
+void Evict(uint64_t targetGuid, uint32_t spellId) {
+    if (targetGuid == 0 || spellId == 0)
+        return;
+    for (auto &e : g_cache) {
+        if (e.used && e.targetGuid == targetGuid && e.spellId == spellId) {
+            e.used = false;
+            return;
+        }
+    }
+}
+
+// Drop entries whose timed aura has elapsed so the table doesn't fill with
+// stale combat debuffs. Infinite-duration entries (expirationMs == 0) stay
+// until overwritten.
+void OnWorldTick() {
+    const uint32_t now = NowMs();
+    for (auto &e : g_cache) {
+        if (e.used && e.expirationMs != 0 && now >= e.expirationMs)
+            e.used = false;
+    }
+}
+
+const Tick::WorldTick::AutoSubscribe _tickSub{&OnWorldTick};
+
+// ---- SMSG_SPELL_GO co-hook ----------------------------------------------
+
+// The hit-target list is all we need: each entry is a unit the cast landed
+// on, which is exactly where an aura gets applied. We deliberately stop
+// before the missed-target list / target mask — the post-mask "intended"
+// target is redundant with the hit list for aura purposes, and skipping it
+// keeps the parse short and robust.
+constexpr int kMaxTargets = 16;
+
+using SpellGo_t = void(__fastcall *)(uint64_t *itemGUID, uint64_t *casterGUID,
+                                     uint32_t spellId, CDataStore *packet);
+SpellGo_t g_origSpellGo = nullptr;
+
+void __fastcall SpellGo_h(uint64_t *itemGUID, uint64_t *casterGUID,
+                          uint32_t spellId, CDataStore *packet) {
+    uint64_t targets[kMaxTargets];
+    int numTargets = 0;
+
+    if (packet != nullptr) {
+        const uint32_t savedRead = packet->m_read;
+        Net::Read<int16_t>(packet); // castFlags (unused)
+        const uint8_t numHit = Net::Read<uint8_t>(packet);
+        for (int i = 0; i < numHit; ++i) {
+            const uint64_t guid = Net::Read<uint64_t>(packet);
+            if (numTargets < kMaxTargets)
+                targets[numTargets++] = guid;
+        }
+        packet->m_read = savedRead; // restore so the engine re-parses cleanly
+    }
+
+    g_origSpellGo(itemGUID, casterGUID, spellId, packet);
+
+    const uint64_t caster = (casterGUID != nullptr) ? *casterGUID : 0;
+    if (caster == 0 || spellId == 0)
+        return;
+
+    const uint8_t *rec = Spell::Lookup::RecordForID(static_cast<int>(spellId));
+    if (!SpellAppliesAura(rec))
+        return;
+
+    const bool casterIsPlayer = (caster == Unit::Identity::PlayerGuid());
+    const uint32_t durationMs = SpellDurationMs(rec, casterIsPlayer);
+    const uint32_t expirationMs = durationMs > 0 ? NowMs() + durationMs : 0;
+
+    if (numTargets == 0) {
+        // No explicit hit list (self-cast with caster-implicit target).
+        Store(caster, spellId, caster, expirationMs, durationMs, true,
+              KIND_UNKNOWN);
+        return;
+    }
+    for (int i = 0; i < numTargets; ++i)
+        Store(targets[i], spellId, caster, expirationMs, durationMs, true,
+              KIND_UNKNOWN);
+}
+
+const Game::HookAutoRegister _hook{Offsets::FUN_SPELL_GO,
+                                   reinterpret_cast<void *>(&SpellGo_h),
+                                   reinterpret_cast<void **>(&g_origSpellGo)};
+
+// ---- Aura-application co-hooks (timing for proc / triggered auras) -------
+
+// Stamp expiration for an aura that just landed/refreshed on `unit`. Used by
+// both the add and stack-change hooks. No caster is available from these
+// paths, so it stamps timing only with `fromCast=false` — Store skips any
+// entry SpellGo already owns, so a directly-cast aura keeps its talented
+// timing. Base (unmodified) duration is the best estimate without a caster.
+void StampApplication(void *unit, uint32_t spellId, int8_t kind) {
+    if (spellId == 0)
+        return;
+    const uint8_t *rec = Spell::Lookup::RecordForID(static_cast<int>(spellId));
+    if (!SpellAppliesAura(rec))
+        return;
+    const uint64_t unitGuid = Unit::Identity::GuidForObject(unit);
+    if (unitGuid == 0)
+        return;
+    const uint32_t durationMs = SpellDurationMs(rec, /*casterIsPlayer*/ false);
+    const uint32_t expirationMs = durationMs > 0 ? NowMs() + durationMs : 0;
+    Store(unitGuid, spellId, /*casterGuid*/ 0, expirationMs, durationMs,
+          /*fromCast*/ false, kind);
+}
+
+// Classify by the absolute aura slot: 0..BUFF_COUNT-1 = buff (helpful),
+// BUFF_COUNT..TOTAL-1 = debuff (harmful).
+int8_t KindForSlot(int slot) {
+    return slot >= Offsets::UNIT_AURA_BUFF_COUNT ? KIND_HARMFUL : KIND_HELPFUL;
+}
+
+// OnAuraAdded — a new aura occupies a slot (gives the spellId directly).
+using OnAuraAdded_t = void(__fastcall *)(void *unit, void *edx, uint32_t slot,
+                                         uint32_t spellId);
+OnAuraAdded_t g_origOnAuraAdded = nullptr;
+
+void __fastcall OnAuraAdded_h(void *unit, void *edx, uint32_t slot,
+                              uint32_t spellId) {
+    g_origOnAuraAdded(unit, edx, slot, spellId);
+    StampApplication(unit, spellId, KindForSlot(static_cast<int>(slot)));
+}
+
+const Game::HookAutoRegister _hookAuraAdded{
+    Offsets::FUN_ON_AURA_ADDED, reinterpret_cast<void *>(&OnAuraAdded_h),
+    reinterpret_cast<void **>(&g_origOnAuraAdded)};
+
+// OnAuraStacksChanged — an existing aura's stack count changed (e.g. Shadow
+// Weaving climbing). Only the slot is given, so read the spellID back from
+// the unit's aura array. Re-stamps expiration so stacking refreshes count.
+using OnAuraStacksChanged_t = void(__fastcall *)(void *unit, void *edx,
+                                                 int slot, uint8_t stackCount);
+OnAuraStacksChanged_t g_origOnAuraStacksChanged = nullptr;
+
+void __fastcall OnAuraStacksChanged_h(void *unit, void *edx, int slot,
+                                      uint8_t stackCount) {
+    g_origOnAuraStacksChanged(unit, edx, slot, stackCount);
+    StampApplication(
+        unit,
+        Aura::Data::ReadSpellID(static_cast<const uint8_t *>(unit), slot),
+        KindForSlot(slot));
+}
+
+const Game::HookAutoRegister _hookAuraStacks{
+    Offsets::FUN_ON_AURA_STACKS_CHANGED,
+    reinterpret_cast<void *>(&OnAuraStacksChanged_h),
+    reinterpret_cast<void **>(&g_origOnAuraStacksChanged)};
+
+// OnAuraRemoved — a descriptor aura slot went empty: the aura fell off, was
+// dispelled, or was replaced by a higher rank (the diff dispatcher fires
+// Removed(old) + Added(new)). Evict the cache entry so the fallback stops
+// surfacing it. Same ABI as OnAuraAdded (unit in ecx, slot + spellId on the
+// stack); `slot` is unused here — we evict by spellId.
+using OnAuraRemoved_t = void(__fastcall *)(void *unit, void *edx, uint32_t slot,
+                                           uint32_t spellId);
+OnAuraRemoved_t g_origOnAuraRemoved = nullptr;
+
+void __fastcall OnAuraRemoved_h(void *unit, void *edx, uint32_t slot,
+                                uint32_t spellId) {
+    g_origOnAuraRemoved(unit, edx, slot, spellId);
+    (void)slot;
+    Evict(Unit::Identity::GuidForObject(unit), spellId);
+}
+
+const Game::HookAutoRegister _hookAuraRemoved{
+    Offsets::FUN_ON_AURA_REMOVED, reinterpret_cast<void *>(&OnAuraRemoved_h),
+    reinterpret_cast<void **>(&g_origOnAuraRemoved)};
+
+} // namespace
+
+bool Get(uint64_t unitGuid, uint32_t spellId, uint64_t *outCaster,
+         uint32_t *outExpirationMs, uint32_t *outDurationMs) {
+    if (unitGuid == 0 || spellId == 0)
+        return false;
+    for (const auto &e : g_cache) {
+        if (e.used && e.targetGuid == unitGuid && e.spellId == spellId) {
+            *outCaster = e.casterGuid;
+            *outExpirationMs = e.expirationMs;
+            *outDurationMs = e.durationMs;
+            return true;
+        }
+    }
+    return false;
+}
+
+int Enumerate(uint64_t unitGuid, bool harmful, CachedAura *out, int maxOut) {
+    if (unitGuid == 0 || out == nullptr || maxOut <= 0)
+        return 0;
+    const int8_t want = harmful ? KIND_HARMFUL : KIND_HELPFUL;
+    const uint32_t now = NowMs();
+    int n = 0;
+    for (const auto &e : g_cache) {
+        if (n >= maxOut)
+            break;
+        if (!e.used || e.targetGuid != unitGuid || e.kind != want)
+            continue;
+        if (e.expirationMs != 0 && now >= e.expirationMs)
+            continue; // expired (infinite-duration entries pass)
+        out[n++] = {e.spellId, e.casterGuid, e.expirationMs, e.durationMs};
+    }
+    return n;
+}
+
+} // namespace Aura::Source
@@ -0,0 +1,65 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+
+#pragma once
+
+#include <cstdint>
+
+// Aura caster / duration cache, fed by a co-hook on `SMSG_SPELL_GO`
+// (`FUN_SPELL_GO`). The vanilla unit aura array (`UNIT_FIELD_AURA`) stores
+// only spell IDs — it has no record of *who* cast an aura, and no
+// cast/expiration timing for any unit but the local player. The one place
+// the client ever sees the caster + a server-authoritative duration is the
+// `SMSG_SPELL_GO` packet at cast time. We parse it (the same packet
+// nampower parses for its `AURA_CAST_ON_*` events) and remember, per
+// `(targetGuid, spellId)`, who cast it and when it should expire.
+//
+// `Aura::Data::Push` consults this to fill `sourceUnit` (caster, resolved
+// to a unit token) and `expirationTime` for non-player units. The cache is
+// inherently best-effort: it only knows about casts observed since login,
+// and an entry survives until it expires (combat-duration auras) or is
+// evicted under pressure. Misses leave the modern-truthful defaults
+// (`sourceUnit` nil, `expirationTime` 0) in place — same outcome as before
+// this module existed.
+
+namespace Aura::Source {
+
+// Looks up the cached caster + timing for the aura `spellId` currently on
+// the unit identified by `unitGuid`. Returns true and fills the out params
+// on a hit. `*outExpirationMs` is an absolute `GetTickCount`-epoch timestamp
+// (0 = unknown / infinite-duration aura); `*outDurationMs` is the applied
+// duration including the caster's modifiers (talents etc.; 0 = none) — use
+// it for the `duration` field so it stays consistent with `expirationTime`;
+// `*outCaster` is the caster's 64-bit GUID (never 0 on a hit). Returns false
+// on a miss or for zero inputs.
+bool Get(uint64_t unitGuid, uint32_t spellId, uint64_t *outCaster,
+         uint32_t *outExpirationMs, uint32_t *outDurationMs);
+
+// One cached aura, as returned by `Enumerate`.
+struct CachedAura {
+    uint32_t spellId;
+    uint64_t casterGuid;   // 0 = caster unknown (application hook, no SpellGo)
+    uint32_t expirationMs; // 0 = infinite / unknown
+    uint32_t durationMs;   // applied duration (incl. caster mods); 0 = none
+};
+
+// Fills `out` with up to `maxOut` cached, non-expired auras on `unitGuid`
+// whose helpful/harmful classification matches `harmful`. Returns the count
+// written. The classification is recorded from the aura's descriptor slot at
+// application time (`OnAuraAdded`/`OnAuraStacksChanged`); entries we only ever
+// saw via `SMSG_SPELL_GO` have no slot and so an unknown classification —
+// those are excluded (we can't tell which range they belong to).
+//
+// This is the fallback source for `Aura::Data` when the unit descriptor has
+// dropped an aura's slot (rogue stealth, party range fluctuation) even though
+// the aura is still active server-side: the cache survives descriptor clears.
+int Enumerate(uint64_t unitGuid, bool harmful, CachedAura *out, int maxOut);
+
+} // namespace Aura::Source
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `BAG_UPDATE_DELAYED` event — fires once per frame in which any
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // Inject ClassicAPI-owned bindings into a chosen engine section.
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -0,0 +1,224 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#include "cache/QueryLoad.h"
+
+#include "Game.h"
+#include "Offsets.h"
+#include "event/Custom.h"
+#include "tick/WorldTick.h"
+
+#include <cstdint>
+
+namespace Cache::QueryLoad {
+
+namespace {
+
+// A cache class's `_GetRecord`. callback=nullptr → pure peek (returns the
+// loaded data block or nullptr, no query). Non-null callback → also fires
+// the network query on a miss and stores `(callback, userData)` on the
+// entry's pending list. dedup=1 so repeat fetches for the same id before
+// the response lands don't queue the callback twice.
+using GetCacheRecord_t = const uint8_t *(__thiscall *)(void *cache, uint32_t id,
+                                                       const uint64_t *guid, void *callback,
+                                                       void *userData, char dedup);
+
+// A cache class's response parser, which we hook (e.g.
+// FUN_CREATURE_QUERY_RESPONSE / FUN_GAMEOBJECT_QUERY_RESPONSE).
+using CacheResponse_t = void(__thiscall *)(void *cache, void *packetReader, int flag);
+
+// Engine callback shape (__stdcall, ret 8) — see Item::Data. We only pass
+// it to make `_GetRecord` send the query (the trigger is callback != 0);
+// completion is observed via the response hook + tick sweep.
+void __stdcall NoOpCallback(void * /*userData*/, int /*success*/) {}
+
+const uint8_t *CacheFetch(uintptr_t getRecord, void *cache, uint32_t id, void *callback) {
+    auto fn = reinterpret_cast<GetCacheRecord_t>(getRecord);
+    const uint64_t zeroGuid = 0;
+    void *userData =
+        callback ? reinterpret_cast<void *>(static_cast<uintptr_t>(id)) : nullptr;
+    return fn(cache, id, &zeroGuid, callback, userData, 1);
+}
+
+struct Pending {
+    uint32_t id;
+    int ticksWaiting;
+};
+
+constexpr int kMaxCaches = 8;
+constexpr int kMaxPending = 256;
+constexpr int kMaxWaitTicks = 1200; // give up and fire failure after this many WorldTicks
+
+struct Registered {
+    void *cache;
+    const char *eventName;
+    uintptr_t getRecord; // this cache class's _GetRecord
+    Pending pending[kMaxPending];
+    int pendingCount;
+};
+
+Registered g_caches[kMaxCaches];
+int g_cacheCount = 0;
+
+Registered *Find(void *cache) {
+    for (int i = 0; i < g_cacheCount; ++i) {
+        if (g_caches[i].cache == cache)
+            return &g_caches[i];
+    }
+    return nullptr;
+}
+
+void Fire(const Registered *r, uint32_t id, bool success) {
+    Event::Custom::FireIdSuccess(Event::Custom::Lookup(r->eventName),
+                                 static_cast<int>(id), success);
+}
+
+int FindPending(const Registered *r, uint32_t id) {
+    for (int i = 0; i < r->pendingCount; ++i) {
+        if (r->pending[i].id == id)
+            return i;
+    }
+    return -1;
+}
+
+void RemovePendingAt(Registered *r, int idx) {
+    --r->pendingCount;
+    if (idx != r->pendingCount)
+        r->pending[idx] = r->pending[r->pendingCount];
+}
+
+bool IsLoaded(const Registered *r, uint32_t id) {
+    return CacheFetch(r->getRecord, r->cache, id, nullptr) != nullptr;
+}
+
+// Fire + remove any pending id whose entry is now loaded.
+void Sweep(Registered *r) {
+    for (int i = 0; i < r->pendingCount;) {
+        if (IsLoaded(r, r->pending[i].id)) {
+            const uint32_t id = r->pending[i].id;
+            RemovePendingAt(r, i);
+            Fire(r, id, true);
+            continue;
+        }
+        ++i;
+    }
+}
+
+// Shared post-response dispatch: a parser for `cache` just ran, so sweep
+// that cache's pending set (no-op for caches we don't track).
+void DispatchSweep(void *cache) {
+    Registered *r = Find(cache);
+    if (r != nullptr)
+        Sweep(r);
+}
+
+// One response-handler hook per cache class. Each calls its own original
+// trampoline (the parser fills the entry + walks the engine's own
+// callback list), then sweeps via the shared dispatch. `__thiscall`
+// mimicked as `__fastcall(ecx, edx_unused, …)`.
+using Trampoline_t = void(__fastcall *)(void *cache, void *edx, void *packetReader, int flag);
+
+CacheResponse_t g_origCreatureParser = nullptr;
+void __fastcall CreatureParser_h(void *cache, void * /*edx*/, void *packetReader, int flag) {
+    reinterpret_cast<Trampoline_t>(g_origCreatureParser)(cache, nullptr, packetReader, flag);
+    DispatchSweep(cache);
+}
+
+CacheResponse_t g_origGameObjectParser = nullptr;
+void __fastcall GameObjectParser_h(void *cache, void * /*edx*/, void *packetReader, int flag) {
+    reinterpret_cast<Trampoline_t>(g_origGameObjectParser)(cache, nullptr, packetReader, flag);
+    DispatchSweep(cache);
+}
+
+const Game::HookAutoRegister _hookCreature{
+    Offsets::FUN_CREATURE_QUERY_RESPONSE, reinterpret_cast<void *>(&CreatureParser_h),
+    reinterpret_cast<void **>(&g_origCreatureParser)};
+const Game::HookAutoRegister _hookGameObject{
+    Offsets::FUN_GAMEOBJECT_QUERY_RESPONSE, reinterpret_cast<void *>(&GameObjectParser_h),
+    reinterpret_cast<void **>(&g_origGameObjectParser)};
+
+// Timeout + safety net. The hooks cover the happy path; this fires
+// failure for ids that never resolve after `kMaxWaitTicks`, and
+// re-checks loaded as a backstop for fills observed off the hook path.
+void OnWorldTick() {
+    for (int c = 0; c < g_cacheCount; ++c) {
+        Registered *r = &g_caches[c];
+        for (int i = 0; i < r->pendingCount;) {
+            if (IsLoaded(r, r->pending[i].id)) {
+                const uint32_t id = r->pending[i].id;
+                RemovePendingAt(r, i);
+                Fire(r, id, true);
+                continue;
+            }
+            if (r->pending[i].ticksWaiting >= kMaxWaitTicks) {
+                const uint32_t id = r->pending[i].id;
+                RemovePendingAt(r, i);
+                Fire(r, id, false);
+                continue;
+            }
+            ++r->pending[i].ticksWaiting;
+            ++i;
+        }
+    }
+}
+
+const Tick::WorldTick::AutoSubscribe _tickSub{&OnWorldTick};
+
+} // namespace
+
+void Register(void *cacheInstance, const char *eventName, uintptr_t getRecordAddr) {
+    if (cacheInstance == nullptr || eventName == nullptr || getRecordAddr == 0)
+        return;
+    if (Find(cacheInstance) != nullptr) // idempotent (safe across /reload)
+        return;
+    if (g_cacheCount >= kMaxCaches)
+        return;
+    g_caches[g_cacheCount].cache = cacheInstance;
+    g_caches[g_cacheCount].eventName = eventName;
+    g_caches[g_cacheCount].getRecord = getRecordAddr;
+    g_caches[g_cacheCount].pendingCount = 0;
+    ++g_cacheCount;
+}
+
+bool IsCached(void *cacheInstance, uint32_t id) {
+    const Registered *r = Find(cacheInstance);
+    return r != nullptr && IsLoaded(r, id);
+}
+
+bool RequestLoad(void *cacheInstance, uint32_t id) {
+    Registered *r = Find(cacheInstance);
+    if (r == nullptr || id == 0)
+        return false;
+
+    // Already cached — fire success synchronously (modern RequestLoad
+    // contract: the completion event fires even on a cache hit).
+    if (IsLoaded(r, id)) {
+        Fire(r, id, true);
+        return true;
+    }
+    // Already in flight — one completion event per id.
+    if (FindPending(r, id) >= 0)
+        return true;
+    if (r->pendingCount >= kMaxPending)
+        return false;
+
+    // Send the query (non-null callback is the trigger), then track until
+    // the response hook / tick fires the event.
+    CacheFetch(r->getRecord, cacheInstance, id, reinterpret_cast<void *>(&NoOpCallback));
+    r->pending[r->pendingCount].id = id;
+    r->pending[r->pendingCount].ticksWaiting = 0;
+    ++r->pendingCount;
+    return true;
+}
+
+} // namespace Cache::QueryLoad
@@ -0,0 +1,65 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include <cstdint>
+
+// Shared async-load machinery for the client query caches that aren't
+// item/quest — creature, gameobject, and (potentially) the other
+// SMSG_*_QUERY caches. Modeled on `Item::Data`'s pending/timeout/event
+// logic, generalized so several caches share one set of code.
+//
+// These caches are sibling classes: they share the record/entry hash-map
+// shape but differ in `_GetRecord` and response-parser per class (the
+// creature class reads its loaded flag at entry+0x50, the gameobject
+// class at +0x98, etc.). So a module registers BOTH its cache's
+// `_GetRecord` address and the dispatcher routes completion by cache
+// instance. The dispatcher hooks each class's response parser (MinHook
+// allows only one hook per target, but the parsers are distinct
+// functions, so hooking creature's and gameobject's separately is fine);
+// item/quest have their own parsers and aren't touched.
+//
+//   static const char *kEvent = "CREATURE_DATA_LOAD_RESULT";
+//   static const Event::Custom::AutoReserve _r{kEvent};   // reserve the event
+//   ...
+//   Cache::QueryLoad::Register(cacheInstance, kEvent,
+//                              Offsets::FUN_CREATURE_GET_RECORD);  // at init
+//   Cache::QueryLoad::RequestLoad(cacheInstance, id);             // fire a load
+//
+// The completion event fires as `(id: number, success: bool)` — success
+// when the cache fills, failure on timeout.
+
+namespace Cache::QueryLoad {
+
+// Register a query cache for async-load tracking. `cacheInstance` is the
+// cache global (e.g. `Offsets::VAR_CREATURE_CACHE` cast to void*);
+// `eventName` is a Custom event the caller has reserved via
+// `Event::Custom::AutoReserve`, fired `(id, success)` on completion;
+// `getRecordAddr` is the cache class's `_GetRecord` (e.g.
+// `Offsets::FUN_CREATURE_GET_RECORD`). `cacheInstance`/`eventName` must
+// outlive the process (pass static values). Idempotent — calling again
+// for the same cache is a no-op (safe across /reload).
+void Register(void *cacheInstance, const char *eventName, uintptr_t getRecordAddr);
+
+// True if `id` is already in the cache (pure peek, no network query).
+bool IsCached(void *cacheInstance, uint32_t id);
+
+// Issue an async load for `id`. If already cached, fires the completion
+// event with success synchronously. Otherwise sends the query and tracks
+// the id until the response lands (or it times out). Returns false only
+// if the cache isn't registered or its pending set is full; true
+// otherwise (already-cached, already-pending, or newly-tracked).
+bool RequestLoad(void *cacheInstance, uint32_t id);
+
+} // namespace Cache::QueryLoad
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `GetSavedCharacterOrder(realm)` / `SetSavedCharacterOrder(realm, order)`
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `GetCurrentChatGUID()` — call from inside an addon's OnEvent for
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // Class metadata accessors backed by `ChrClasses.dbc`.
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_Container.GetContainerItemCharges(containerIndex, slotIndex)` —
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_Container.GetItemCooldown(itemID)` — modern signature only
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_Container.GetContainerItemDurability(containerIndex, slotIndex)` —
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_Container.GetContainerItemID(bagIndex, slotIndex)` — modern
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_Container.MoveItem(srcBag, srcSlot, dstBag, dstSlot, count)` —
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_Container.IsContainerItemOpenable(bag, slot)` — positional-arg
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_Container.GetContainerItemRepairCost(containerIndex, slotIndex)`
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_Container.SwapItems(srcBag, srcSlot, dstBag, dstSlot)` — atomic
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
 //
 // Restores Lua 5.0's stripped `coroutine.*` library to the in-game Lua
@@ -0,0 +1,138 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `C_CreatureInfo.GetCreatureInfoByID(creatureID)` -> table | nil
+//
+// Reads the client-side creature cache (creaturecache.wdb, fed by
+// SMSG_CREATURE_QUERY_RESPONSE) for a creature/NPC by ID and returns:
+//
+//   {
+//     creatureID = <id>,
+//     name       = "Misthoof Stag",   -- primary name
+//     subName    = "",                 -- title/subtitle ("" if none)
+//     type       = 1,                  -- CreatureType (1=Beast, 7=Humanoid, …)
+//     family     = 0,                  -- CreatureFamily
+//     rank       = 0,                  -- 0=normal,1=elite,2=rareelite,3=worldboss,4=rare
+//     displayID  = 10957,              -- model display ID
+//   }
+//
+// `GetCreatureInfoByID` is a synchronous *peek*: returns the data only
+// if the creature is already cached (seen this session, or loaded from
+// creaturecache.wdb at login); nil otherwise. `RequestLoadCreatureByID`
+// fetches an uncached creature — it issues the query and fires
+// `CREATURE_DATA_LOAD_RESULT(creatureID, success)` when the response
+// lands, via the shared `Cache::QueryLoad` dispatcher.
+//
+// Field offsets verified against the binary (rank read by the engine's
+// classification helper as `[block+0x20]`) and real creaturecache.wdb
+// rows. See Offsets.h `OFF_CREATURE_*`.
+
+#include "Game.h"
+#include "Offsets.h"
+#include "cache/QueryLoad.h"
+#include "event/Custom.h"
+
+#include <cstdint>
+
+namespace Creature::Info {
+
+namespace {
+
+// Completion event for RequestLoadCreatureByID. Reserved at static-init
+// so the engine allocates it in its event table; fired (creatureID,
+// success) by the Cache::QueryLoad dispatcher.
+constexpr const char *kCreatureDataLoadResult = "CREATURE_DATA_LOAD_RESULT";
+const Event::Custom::AutoReserve _reserveLoadResult{kCreatureDataLoadResult};
+
+// Generic cache `_GetRecord`. With callback=nullptr it only peeks the
+// hash table (no network query) and returns the data block (entry+0x18)
+// if the creature is loaded, else nullptr.
+using GetCacheRecord_t = const uint8_t *(__thiscall *)(void *cache, uint32_t id,
+                                                       const uint64_t *guid, void *callback,
+                                                       void *userData, char dedup);
+
+const uint8_t *PeekCreature(uint32_t creatureID) {
+    auto fn = reinterpret_cast<GetCacheRecord_t>(Offsets::FUN_CREATURE_GET_RECORD);
+    auto *cache = reinterpret_cast<void *>(Offsets::VAR_CREATURE_CACHE);
+    const uint64_t zeroGuid = 0;
+    return fn(cache, creatureID, &zeroGuid, nullptr, nullptr, 0);
+}
+
+int __fastcall Script_GetCreatureInfoByID(void *L) {
+    if (!Game::Lua::IsNumber(L, 1))
+        return 0; // nil
+    const int creatureID = static_cast<int>(Game::Lua::ToNumber(L, 1));
+    if (creatureID <= 0)
+        return 0;
+
+    const uint8_t *rec = PeekCreature(static_cast<uint32_t>(creatureID));
+    if (rec == nullptr)
+        return 0; // not cached -> nil
+
+    const char *name = *reinterpret_cast<const char *const *>(rec + Offsets::OFF_CREATURE_NAME);
+    const char *subName =
+        *reinterpret_cast<const char *const *>(rec + Offsets::OFF_CREATURE_SUBNAME);
+    const uint32_t type = *reinterpret_cast<const uint32_t *>(rec + Offsets::OFF_CREATURE_TYPE);
+    const uint32_t family = *reinterpret_cast<const uint32_t *>(rec + Offsets::OFF_CREATURE_FAMILY);
+    const uint32_t rank = *reinterpret_cast<const uint32_t *>(rec + Offsets::OFF_CREATURE_RANK);
+    const uint32_t displayID =
+        *reinterpret_cast<const uint32_t *>(rec + Offsets::OFF_CREATURE_DISPLAYID);
+
+    Game::Lua::NewTable(L);
+    Game::Lua::SetFieldNumber(L, "creatureID", creatureID);
+    Game::Lua::SetFieldString(L, "name", name);       // NULL coerced to ""
+    Game::Lua::SetFieldString(L, "subName", subName);
+    Game::Lua::SetFieldNumber(L, "type", type);
+    Game::Lua::SetFieldNumber(L, "family", family);
+    Game::Lua::SetFieldNumber(L, "rank", rank);
+    Game::Lua::SetFieldNumber(L, "displayID", displayID);
+    return 1;
+}
+
+// `C_CreatureInfo.RequestLoadCreatureByID(creatureID)` -> bool. Async
+// fetch for an uncached creature: issues SMSG_CREATURE_QUERY and fires
+// `CREATURE_DATA_LOAD_RESULT(creatureID, success)` when the response
+// lands (or on timeout). Fires success synchronously if already cached.
+// Returns true if the request was accepted (false for bad input or a
+// full pending set) — mirrors C_Item.RequestLoadItemData(ByID).
+int __fastcall Script_RequestLoadCreatureByID(void *L) {
+    if (!Game::Lua::IsNumber(L, 1)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+    const int creatureID = static_cast<int>(Game::Lua::ToNumber(L, 1));
+    if (creatureID <= 0) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+    auto *cache = reinterpret_cast<void *>(Offsets::VAR_CREATURE_CACHE);
+    const bool accepted =
+        Cache::QueryLoad::RequestLoad(cache, static_cast<uint32_t>(creatureID));
+    Game::Lua::PushBool(L, accepted);
+    return 1;
+}
+
+void RegisterLuaFunctions() {
+    Game::Lua::RegisterTableFunction("C_CreatureInfo", "GetCreatureInfoByID",
+                                     &Script_GetCreatureInfoByID);
+    Game::Lua::RegisterTableFunction("C_CreatureInfo", "RequestLoadCreatureByID",
+                                     &Script_RequestLoadCreatureByID);
+    Cache::QueryLoad::Register(reinterpret_cast<void *>(Offsets::VAR_CREATURE_CACHE),
+                               kCreatureDataLoadResult, Offsets::FUN_CREATURE_GET_RECORD);
+}
+
+const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+} // namespace
+
+} // namespace Creature::Info
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `GetCursorInfo()` — backport of the modern WoW global. Surfaces
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -0,0 +1,101 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#include "cvar/Factory.h"
+
+#include "Offsets.h"
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+
+namespace CVar::Factory {
+
+namespace {
+
+// `FUN_REGISTER_CVAR` — verified ABI (see Offsets.h and the calibration
+// against the engine's own call site at 0x005E2490 / the Lua
+// Script_RegisterCVar path). MSVC `__fastcall` places the first two args in
+// ECX/EDX and pushes the rest right-to-left, which reproduces the engine's
+// exact push order: flags, defaultValue, callback, categoryId, hiddenBool,
+// userData (with flags as the first stack arg / last push).
+using RegisterCVar_t = void *(__fastcall *)(const char *name, int edxZero,
+                                            uint32_t flags,
+                                            const char *defaultValue,
+                                            ChangeCallback callback,
+                                            int categoryId, int hiddenBool,
+                                            void *userData);
+
+using FindCVar_t = void *(__fastcall *)(const char *name);
+
+// `FUN_SET_CVAR_VALUE` — `__thiscall(cvar /*ecx*/, value, a3, a4, a5, a6)`,
+// i.e. ECX=cvar with `value` AND a3..a6 all passed on the stack (5 stack
+// args; the function cleans 20 bytes / `RET 0x14`). NOT __fastcall — that
+// would route `value` through EDX, push only 4 args, and leave the callee
+// popping 4 bytes too many → ESP corruption → silent crash. Mirror the
+// Script_SetCVar invocation (0x00488CA8): a3..a6 = 1, 0, 0, 1.
+using SetCVarValue_t = char(__thiscall *)(void *cvar, const char *value,
+                                          int a3, int a4, int a5, int a6);
+
+const char *ReadValue(void *cvar) {
+    if (cvar == nullptr)
+        return nullptr;
+    return *reinterpret_cast<const char *const *>(
+        static_cast<const uint8_t *>(cvar) + Offsets::OFF_CVAR_VALUE_STR);
+}
+
+} // namespace
+
+Handle Register(const char *name, const char *defaultValue, uint32_t flags,
+                ChangeCallback callback, void *userData) {
+    if (name == nullptr)
+        return nullptr;
+    auto reg = reinterpret_cast<RegisterCVar_t>(Offsets::FUN_REGISTER_CVAR);
+    return reg(name, /*edxZero*/ 0, flags, defaultValue, callback,
+               Offsets::CVAR_SCRIPT_CATEGORY, /*hiddenBool*/ 0, userData);
+}
+
+Handle Find(const char *name) {
+    if (name == nullptr)
+        return nullptr;
+    auto find = reinterpret_cast<FindCVar_t>(Offsets::FUN_FIND_CVAR);
+    return find(name);
+}
+
+const char *GetString(Handle cvar) {
+    return ReadValue(cvar);
+}
+
+int GetInt(Handle cvar, int fallback) {
+    const char *value = ReadValue(cvar);
+    if (value == nullptr || value[0] == '\0')
+        return fallback;
+    return std::atoi(value);
+}
+
+void SetString(Handle cvar, const char *value) {
+    if (cvar == nullptr || value == nullptr)
+        return;
+    auto set = reinterpret_cast<SetCVarValue_t>(Offsets::FUN_SET_CVAR_VALUE);
+    set(cvar, value, 1, 0, 0, 1);
+}
+
+void SetInt(Handle cvar, int value) {
+    char buf[16];
+    // Hand-format to avoid pulling in a locale-aware path; value range for
+    // our cvars is small, 16 bytes is ample for a 32-bit int + sign + NUL.
+    std::snprintf(buf, sizeof buf, "%d", value);
+    SetString(cvar, buf);
+}
+
+} // namespace CVar::Factory
@@ -0,0 +1,80 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include <cstdint>
+
+// CVar::Factory — create and drive engine CVars from C++.
+//
+// Vanilla 1.12 only exposes CVar *reading* and *registration without a
+// callback* through Lua (`RegisterCVar(name, default)`); there's no way for
+// an addon to register a cvar with a change-callback or to react to value
+// changes. This wraps the engine's internal registrar (`FUN_REGISTER_CVAR`)
+// and value-setter (`FUN_SET_CVAR_VALUE`) so other modules can publish
+// persisted, validated settings (clamped via the change callback and saved
+// to Config.wtf).
+//
+// CVars registered here persist to `WTF\Config.wtf` (the engine forces the
+// archive flag bit on at registration) and are visible to the in-game Lua
+// `GetCVar`/`SetCVar` globals, since cvar storage is process-global.
+
+namespace CVar::Factory {
+
+// Opaque handle to an engine CVar. Stable for the cvar's lifetime (vanilla
+// never reallocates a registered cvar).
+using Handle = void *;
+
+// Change callback. Fires whenever the cvar's value changes (and once at
+// registration). Mirrors the engine ABI verified at FUN_SET_CVAR_VALUE:
+//   - `cvar`      — this cvar's Handle
+//   - `prevValue` — the value before the change (may be null/empty)
+//   - `newValue`  — the value being applied
+//   - `userData`  — whatever was passed to Register
+// Return a nonzero value to ACCEPT the change, 0 to REJECT it (the engine
+// keeps the previous value). To clamp rather than reject, set the clamped
+// value with SetString from inside the callback and return 0 for the
+// out-of-range input. Must tolerate being invoked with partial context.
+using ChangeCallback = int(__fastcall *)(Handle cvar, const char *prevValue,
+                                         const char *newValue, void *userData);
+
+// Register a cvar (or fetch the existing one — the engine dedups by name,
+// and re-registering OR-merges `flags` and updates the callback). `name`
+// and `defaultValue` must outlive the process (the engine stores `name` by
+// pointer; pass string literals). `defaultValue` may be null for "". The
+// returned Handle is never null on success; null only if the engine
+// registrar itself failed.
+Handle Register(const char *name, const char *defaultValue,
+                uint32_t flags = 0, ChangeCallback callback = nullptr,
+                void *userData = nullptr);
+
+// Look up an already-registered cvar by name, or null if none.
+Handle Find(const char *name);
+
+// Read the cvar's current value string (the raw engine pointer at
+// `+OFF_CVAR_VALUE_STR`). Returns null if `cvar` is null. The pointer is
+// valid for the cvar's lifetime.
+const char *GetString(Handle cvar);
+
+// Read the value parsed as a base-10 integer, or `fallback` if `cvar` is
+// null or the value isn't numeric.
+int GetInt(Handle cvar, int fallback = 0);
+
+// Set the cvar's value (fires its change callback). No-op if `cvar` is
+// null. `value` is copied by the engine into the cvar's inline buffer.
+void SetString(Handle cvar, const char *value);
+
+// Convenience: set from an integer.
+void SetInt(Handle cvar, int value);
+
+} // namespace CVar::Factory
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // Glue-side CVar bindings. Vanilla 1.12 registers `GetCVar`,
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Lookup.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Log.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // Temporary probe helpers used to derive byte offsets in the player /
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_EncodingUtil.EncodeBase64` / `DecodeBase64`, with `Base64Variant`
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_EncodingUtil.CompressString` / `DecompressString`, full
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_EquipmentSet.*` — backports the modern equipment-set API on top
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Data.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Locations.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Storage.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `GameTooltip:SetEquipmentSet(name)` — modern method that fills the
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Custom.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // FACTION_STANDING_CHANGED — fires once per reputation change with
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // Restores `UNIT_FACTION("player")` event semantics that vanilla 1.12.1
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_FriendList.SendWhoQueryByName` — sends a /who name-filter query
@@ -0,0 +1,117 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `C_GameObjectInfo.GetGameObjectInfoByID(gameObjectID)` -> table | nil
+// `C_GameObjectInfo.RequestLoadGameObjectByID(gameObjectID)` -> bool
+//
+// The gameobject analog of `C_CreatureInfo`. Reads the client-side
+// gameobject cache (gameobjectcache.wdb, fed by
+// SMSG_GAMEOBJECT_QUERY_RESPONSE) by GO entry ID:
+//
+//   {
+//     gameObjectID = <id>,
+//     name         = "Mesa Elevator",
+//     type         = 11,      -- GameObjectType (0=door,3=chest,…)
+//     displayID    = 360,     -- model display ID
+//   }
+//
+// `GetGameObjectInfoByID` is a synchronous peek (nil if not cached);
+// `RequestLoadGameObjectByID` fetches an uncached GO and fires
+// `GAMEOBJECT_DATA_LOAD_RESULT(gameObjectID, success)` when it lands.
+//
+// The GO cache is a sibling class to the creature cache (its own
+// `_GetRecord` and response parser), but it rides the same shared
+// `Cache::QueryLoad` dispatcher. Field offsets: name@+0x08 verified
+// (FUN_0062dc10 reads `[block+0x08]`), type@+0x00 / displayID@+0x04 from
+// the wire/WDB field order. See Offsets.h `OFF_GAMEOBJECT_*`.
+
+#include "Game.h"
+#include "Offsets.h"
+#include "cache/QueryLoad.h"
+#include "event/Custom.h"
+
+#include <cstdint>
+
+namespace GameObject::Info {
+
+namespace {
+
+constexpr const char *kGameObjectDataLoadResult = "GAMEOBJECT_DATA_LOAD_RESULT";
+const Event::Custom::AutoReserve _reserveLoadResult{kGameObjectDataLoadResult};
+
+using GetCacheRecord_t = const uint8_t *(__thiscall *)(void *cache, uint32_t id,
+                                                       const uint64_t *guid, void *callback,
+                                                       void *userData, char dedup);
+
+// Peek the GO cache (no network query).
+const uint8_t *PeekGameObject(uint32_t goID) {
+    auto fn = reinterpret_cast<GetCacheRecord_t>(Offsets::FUN_GAMEOBJECT_GET_RECORD);
+    auto *cache = reinterpret_cast<void *>(Offsets::VAR_GAMEOBJECT_CACHE);
+    const uint64_t zeroGuid = 0;
+    return fn(cache, goID, &zeroGuid, nullptr, nullptr, 0);
+}
+
+int __fastcall Script_GetGameObjectInfoByID(void *L) {
+    if (!Game::Lua::IsNumber(L, 1))
+        return 0; // nil
+    const int goID = static_cast<int>(Game::Lua::ToNumber(L, 1));
+    if (goID <= 0)
+        return 0;
+
+    const uint8_t *rec = PeekGameObject(static_cast<uint32_t>(goID));
+    if (rec == nullptr)
+        return 0; // not cached -> nil
+
+    const uint32_t type = *reinterpret_cast<const uint32_t *>(rec + Offsets::OFF_GAMEOBJECT_TYPE);
+    const uint32_t displayID =
+        *reinterpret_cast<const uint32_t *>(rec + Offsets::OFF_GAMEOBJECT_DISPLAYID);
+    const char *name = *reinterpret_cast<const char *const *>(rec + Offsets::OFF_GAMEOBJECT_NAME);
+
+    Game::Lua::NewTable(L);
+    Game::Lua::SetFieldNumber(L, "gameObjectID", goID);
+    Game::Lua::SetFieldString(L, "name", name); // NULL coerced to ""
+    Game::Lua::SetFieldNumber(L, "type", type);
+    Game::Lua::SetFieldNumber(L, "displayID", displayID);
+    return 1;
+}
+
+int __fastcall Script_RequestLoadGameObjectByID(void *L) {
+    if (!Game::Lua::IsNumber(L, 1)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+    const int goID = static_cast<int>(Game::Lua::ToNumber(L, 1));
+    if (goID <= 0) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+    auto *cache = reinterpret_cast<void *>(Offsets::VAR_GAMEOBJECT_CACHE);
+    const bool accepted = Cache::QueryLoad::RequestLoad(cache, static_cast<uint32_t>(goID));
+    Game::Lua::PushBool(L, accepted);
+    return 1;
+}
+
+void RegisterLuaFunctions() {
+    Game::Lua::RegisterTableFunction("C_GameObjectInfo", "GetGameObjectInfoByID",
+                                     &Script_GetGameObjectInfoByID);
+    Game::Lua::RegisterTableFunction("C_GameObjectInfo", "RequestLoadGameObjectByID",
+                                     &Script_RequestLoadGameObjectByID);
+    Cache::QueryLoad::Register(reinterpret_cast<void *>(Offsets::VAR_GAMEOBJECT_CACHE),
+                               kGameObjectDataLoadResult, Offsets::FUN_GAMEOBJECT_GET_RECORD);
+}
+
+const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+} // namespace
+
+} // namespace GameObject::Info
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_GossipInfo.*` — retail-shaped wrappers around vanilla 1.12's
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,12 +1,12 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.

 #include "Game.h"
 #include "guid/Guid.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Guid.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `GLOBAL_MOUSE_DOWN` / `GLOBAL_MOUSE_UP` — modern WoW fires these
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `ExportInterfaceFiles art|code` — backport of the 4.3.4 developer-
@@ -20,6 +20,14 @@
 //   code → .lua / .xml / .toc / .xsd  →  BlizzardInterfaceCode\...
 //   art  → .blp / .tga                →  BlizzardInterfaceArt\...
 //
+// `ExportDBCFiles` — ClassicAPI-original companion that dumps every
+// `.dbc` table the client loads to `DBFilesClient\`. It unions the MPQ
+// `(listfile)` with a scan of `.text` for the DBC path-getter pattern
+// (`mov eax, &"DBFilesClient\X.dbc"; ret`) — the latter is the
+// authoritative "what does this build load" list, since the master DBC
+// init is straight-line (no name table), and it catches the ~18 DBCs the
+// listfile doesn't index. See `ScanPathGetters`.
+//
 // Files land relative to the client's working directory, mirroring the
 // retail command's `BlizzardInterface{Code,Art}\<relative-path>`
 // layout. On completion it writes a "wrote N files" line back to the
@@ -55,6 +63,7 @@

 #include <cstdint>
 #include <cstdio>
+#include <cstring>
 #include <string>
 #include <unordered_set>
 #include <vector>
@@ -145,58 +154,112 @@ bool WriteFileToDisk(const std::string &relPath, const void *data, unsigned int
    return ok;
 }

-// Length of the "Interface\" prefix we strip from MPQ paths before
-// re-rooting under the destination folder.
-constexpr size_t kRootPrefixLen = 10; // strlen("Interface\\")
-
 const char *const kCodeExts[] = {"lua", "xml", "toc", "xsd"};
 const char *const kArtExts[] = {"blp", "tga"};
+const char *const kDbcExts[] = {"dbc"};

 enum Mode { MODE_CODE, MODE_ART };

-// Collector for the MPQ enumeration callback. File-static because
-// FUN_00401470 hands the callback only the path string; enumeration is
-// synchronous and single-threaded, so a file-static sink is safe.
+std::string LowerCopy(const char *s) {
+    std::string out;
+    for (const char *p = s; *p; ++p) {
+        char c = *p;
+        if (c >= 'A' && c <= 'Z') c = static_cast<char>(c + ('a' - 'A'));
+        out.push_back(c);
+    }
+    return out;
+}
+
+// Collector for the MPQ enumeration callback (and the path-getter scan).
+// File-static because FUN_00401470 hands the callback only the path
+// string; enumeration is synchronous and single-threaded, so a
+// file-static sink is safe.
 struct Collector {
    const char *const *exts = nullptr;
    int extCount = 0;
    std::vector<std::string> files;
-    std::unordered_set<std::string> seen; // dedup across archives
+    std::unordered_set<std::string> seen; // lowercased keys — dedup across sources
+
+    // Case-insensitive dedup so the listfile and the path-getter scan
+    // (which may differ in casing) never write the same DBC twice.
+    void Add(const char *path) {
+        if (seen.insert(LowerCopy(path)).second)
+            files.emplace_back(path);
+    }
 };
 Collector *g_collector = nullptr;

 // MPQ enumeration callback — one call per listfile entry under the
-// "Interface\" prefix. Keep going (return 1) regardless.
+// active prefix. Keep going (return 1) regardless.
 int __fastcall CollectCb(const char *fullPath) {
    Collector *c = g_collector;
    if (c != nullptr && fullPath != nullptr &&
-        HasExtension(fullPath, c->exts, c->extCount)) {
-        if (c->seen.insert(fullPath).second)
-            c->files.emplace_back(fullPath);
-    }
+        HasExtension(fullPath, c->exts, c->extCount))
+        c->Add(fullPath);
    return 1; // 0 would stop enumeration
 }

-// Enumerate every MPQ file under Interface\ whose extension matches
-// `mode`, read each, and write it under the destination root. Returns
-// the number of files successfully written.
-int ExportTree(Mode mode) {
-    auto MpqEnumFiles = reinterpret_cast<MpqEnumFiles_t>(Offsets::FUN_MPQ_ENUM_FILES);
+// --- DBC path-getter scan ---------------------------------------------
+//
+// The DBC loaders aren't driven by any iterable name table — the master
+// init (`FUN_0053f8b0`) is straight-line, calling ~150 per-DBC loaders in
+// sequence, each of which calls its own one-instruction path-getter:
+//
+//     B8 <&"DBFilesClient\Foo.dbc">   mov eax, <strVA>
+//     C3                              ret
+//
+// So the authoritative, dynamic list of "what DBCs does this build load"
+// is the set of those getters. We recover it the same way docs/DBCs.md
+// did — scan `.text` for the `B8 imm32 C3` pattern and keep matches whose
+// immediate points at a `.dbc` string. This catches every loaded table,
+// including the ~18 the MPQ `(listfile)` doesn't index.
+
+// Build-specific bounds (this 1.12.1 client). `.text` per CLAUDE.md; the
+// image range bounds candidate string pointers so the suffix check never
+// dereferences unmapped memory. Getter strings live in `.data` (e.g.
+// Spell.dbc at 0x00859E30), comfortably inside the image.
+constexpr uintptr_t kTextStart = 0x00401000;
+constexpr uintptr_t kTextEnd = 0x007FEDAC;
+constexpr uintptr_t kImageStart = 0x00400000;
+constexpr uintptr_t kImageEnd = 0x00D26000;
+
+// True if `s` (bounded, never reading past the image) names a ".dbc" file.
+bool LooksLikeDbcString(const uint8_t *s) {
+    const uint8_t *limit = reinterpret_cast<const uint8_t *>(kImageEnd);
+    size_t n = 0;
+    while (n < 260 && s + n < limit && s[n] != '\0')
+        ++n;
+    if (s + n >= limit || s[n] != '\0' || n < 4) // not terminated, or too short
+        return false;
+    return EqualsCI(reinterpret_cast<const char *>(s + n - 4), ".dbc");
+}
+
+// Scan .text for the DBC path-getter pattern and add each referenced
+// ".dbc" path to the collector. Synchronous, reads only our own image.
+void ScanPathGetters(Collector &c) {
+    const uint8_t *p = reinterpret_cast<const uint8_t *>(kTextStart);
+    const uint8_t *end = reinterpret_cast<const uint8_t *>(kTextEnd) - 6;
+    for (; p <= end; ++p) {
+        if (p[0] != 0xB8 || p[5] != 0xC3) // mov eax, imm32 ; ret
+            continue;
+        uint32_t imm;
+        std::memcpy(&imm, p + 1, sizeof(imm));
+        if (imm < kImageStart || imm >= kImageEnd)
+            continue;
+        const uint8_t *s = reinterpret_cast<const uint8_t *>(imm);
+        if (LooksLikeDbcString(s))
+            c.Add(reinterpret_cast<const char *>(s));
+    }
+}
+
+// Read each collected source path from the MPQs and write it under
+// `dstRoot`, re-rooted by stripping the leading `prefixLen` chars (the
+// "Interface\" / "DBFilesClient\" prefix). Returns the number written.
+int WriteFiles(const std::vector<std::string> &files, size_t prefixLen,
+               const char *dstRoot) {
    auto FileRead = reinterpret_cast<FileRead_t>(Offsets::FUN_FILE_READ);
    auto SMemFree = reinterpret_cast<SMemFree_t>(Offsets::FUN_STORM_SMEM_FREE);

-    const char *dstRoot =
-        (mode == MODE_ART) ? "BlizzardInterfaceArt" : "BlizzardInterfaceCode";
-
-    Collector collector;
-    collector.exts = (mode == MODE_ART) ? kArtExts : kCodeExts;
-    collector.extCount = (mode == MODE_ART) ? 2 : 4;
-
-    g_collector = &collector;
-    MpqEnumFiles(kArchiveSelector, "Interface\\", &CollectCb, nullptr);
-    g_collector = nullptr;
-
-    const std::vector<std::string> &files = collector.files;
    int written = 0;
    for (const std::string &src : files) {
        void *buf = nullptr;
@@ -204,10 +267,10 @@ int ExportTree(Mode mode) {
        if (FileRead(0, src.c_str(), &buf, &size, 0, 1, 0) == 0 || buf == nullptr)
            continue;

-        // Re-root: "Interface\FrameXML\Foo.lua" -> "<dstRoot>\FrameXML\Foo.lua".
+        // Re-root: "<prefix>Sub\Foo.ext" -> "<dstRoot>\Sub\Foo.ext".
        std::string dst = dstRoot;
        dst.push_back('\\');
-        dst.append(src, kRootPrefixLen, std::string::npos);
+        dst.append(src, prefixLen, std::string::npos);

        if (WriteFileToDisk(dst, buf, size))
            ++written;
@@ -217,6 +280,47 @@ int ExportTree(Mode mode) {
    return written;
 }

+// Enumerate every MPQ file under `pathPrefix` whose extension matches
+// one of `exts`, read each, and write it under `dstRoot`. Returns the
+// number of files successfully written.
+int ExportTree(const char *pathPrefix, const char *const *exts, int extCount,
+               const char *dstRoot) {
+    auto MpqEnumFiles = reinterpret_cast<MpqEnumFiles_t>(Offsets::FUN_MPQ_ENUM_FILES);
+
+    Collector collector;
+    collector.exts = exts;
+    collector.extCount = extCount;
+
+    g_collector = &collector;
+    MpqEnumFiles(kArchiveSelector, pathPrefix, &CollectCb, nullptr);
+    g_collector = nullptr;
+
+    return WriteFiles(collector.files, std::strlen(pathPrefix), dstRoot);
+}
+
+// Export the DBC tables. Unions two sources, deduped case-insensitively:
+//   1. the MPQ (listfile) under DBFilesClient\ (catches files that ship
+//      in the archives without a loader, e.g. wowerror_strings.dbc), and
+//   2. the .text path-getter scan (the authoritative set the client
+//      actually loads — catches the ~18 DBCs absent from the listfile).
+// Every DBC path is "DBFilesClient\Name.dbc", so re-rooting strips that
+// 14-char prefix and writes under `dstRoot`.
+int ExportDBC(const char *dstRoot) {
+    auto MpqEnumFiles = reinterpret_cast<MpqEnumFiles_t>(Offsets::FUN_MPQ_ENUM_FILES);
+
+    Collector collector;
+    collector.exts = kDbcExts;
+    collector.extCount = 1;
+
+    g_collector = &collector;
+    MpqEnumFiles(kArchiveSelector, "DBFilesClient\\", &CollectCb, nullptr);
+    g_collector = nullptr;
+
+    ScanPathGetters(collector);
+
+    return WriteFiles(collector.files, std::strlen("DBFilesClient\\"), dstRoot);
+}
+
 // Console-command handler ABI: edx = the argument text after the
 // command name ("" when bare). Mirrors 4.3.4's `art`/`code` dispatch.
 bool FirstTokenEquals(const char *s, const char *token) {
@@ -246,7 +350,11 @@ int __fastcall Console_ExportInterfaceFiles(void * /*unused*/, const char *args)
        return 1;
    }

-    const int written = ExportTree(mode);
+    const int written = ExportTree(
+        "Interface\\",
+        (mode == MODE_ART) ? kArtExts : kCodeExts,
+        (mode == MODE_ART) ? 2 : 4,
+        (mode == MODE_ART) ? "BlizzardInterfaceArt" : "BlizzardInterfaceCode");

    char msg[160];
    snprintf(msg, sizeof(msg), "ExportInterfaceFiles: wrote %d %s file(s) to %s\\",
@@ -256,6 +364,21 @@ int __fastcall Console_ExportInterfaceFiles(void * /*unused*/, const char *args)
    return 1;
 }

+// `ExportDBCFiles` — ClassicAPI-original companion to ExportInterfaceFiles.
+// Dumps every `.dbc` table the client loads to `DBFilesClient\` under the
+// working directory. No subcommand — there's only one thing to export.
+// Unions the MPQ (listfile) with a `.text` path-getter scan so it gets
+// the complete set the client loads, including DBCs the listfile omits.
+int __fastcall Console_ExportDBCFiles(void * /*unused*/, const char * /*args*/) {
+    const int written = ExportDBC("DBFilesClient");
+
+    char msg[96];
+    snprintf(msg, sizeof(msg),
+             "ExportDBCFiles: wrote %d .dbc file(s) to DBFilesClient\\", written);
+    Game::Console::Write(msg);
+    return 1;
+}
+
 // Register the console command. A console command is process-global
 // (not Lua-state-bound) and persists for the whole session, so the
 // single registration at glue boot — the earliest hook, firing at
@@ -272,6 +395,11 @@ void EnsureRegistered() {
        Game::Console::CATEGORY_DEBUG,
        "Extracts Blizzard's UI files from the MPQs to disk. "
        "Usage: ExportInterfaceFiles art|code");
+    Game::Console::RegisterCommand(
+        "ExportDBCFiles", &Console_ExportDBCFiles,
+        Game::Console::CATEGORY_DEBUG,
+        "Extracts the client's .dbc tables from the MPQs to disk. "
+        "Usage: ExportDBCFiles");
 }

 const Game::GlueModuleAutoRegister _autoreg{&EnsureRegistered};
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "item/Arg.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,12 +1,12 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.

 // `GetAverageItemLevel()` → `(avgItemLevel, avgItemLevelEquipped)` —
 // polyfills the modern 2.4+ global with the same 2-tuple shape as
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Charges.h"
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,12 +1,12 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.

 // `GetItemCooldown(itemInfo)` — direct-by-ID item cooldown query.
 // Vanilla ships `GetContainerItemCooldown(bag, slot)` and
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #pragma once
@@ -1,14 +1,14 @@
 // This file is part of ClassicAPI.
 //
 // ClassicAPI is free software: you can redistribute it and/or modify it under the terms
-// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// of the GNU General Public License as published by the Free Software Foundation, either
 // version 3 of the License, or (at your option) any later version.
 //
 // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-// PURPOSE. See the GNU Lesser General Public License for more details.
+// PURPOSE. See the GNU General Public License for more details.
 //
-// You should have received a copy of the GNU Lesser General Public License along with
+// You should have received a copy of the GNU General Public License along with
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 #include "Game.h"
--- a/Show More
+++ b/Show More