Per-request / per-row mixin re-integration and reflective dispatch tax on the hottest framework paths

[bpamiri]

Problem

The framework re-derives application-lifetime-constant data on its hottest paths, in four compounding ways. All file:line references verified against origin/develop @ 0688d914b.

1. Full mixin re-integration per model object and per HTTP request

• vendor/wheels/Model.cfc:5 — every model object instantiation calls $integrateComponents("wheels.model"). That runs a directoryList over vendor/wheels/model/ plus one createObject per CFC (~18 files) (Model.cfc:545-557), then a getMetaData().functions scan and a ~245-function-reference copy into variables/this (Model.cfc:562-593). findAll(returnAs="objects") over N rows pays all of this N times.
• vendor/wheels/Controller.cfc:4-5 — every request does the same twice (wheels.controller, 14 CFCs + wheels.view, 15 CFCs; ~266 functions) via Controller.cfc:148-193.

2. Throwaway wheels.Plugins (+ its 4,038-line wheels.Global parent) constructed per request and per row

• vendor/wheels/Controller.cfc:216 and vendor/wheels/Model.cfc:650 — onDIcomplete() runs new wheels.Plugins().$initializeMixins(variables) per controller instance and per materialized model object.
• vendor/wheels/events/EventMethods.cfc:156 — $runOnRequestStart constructs local.Mixins = new wheels.Plugins() unconditionally at the top of every request, but only uses it inside the !StructIsEmpty(application.wheels.mixins) guard (EventMethods.cfc:219-222) — 100% wasted for mixin-free apps. Each construction also pays the Global pseudo-constructor work, including the $promoteIncludedGlobalsToThis() variables-scope scan (vendor/wheels/Global.cfc:4017, 4026-4037).
• Further call sites: vendor/wheels/Dispatch.cfc:809, vendor/wheels/Test.cfc:802.
• A cached instance already exists — application[appKey].PluginObj (vendor/wheels/Global.cfc:3072) — but it cannot be shared safely today: $initializeMixins (vendor/wheels/Plugins.cfc:792-840) makes unscoped $wheels.* scratch writes into the component's own variables scope (a data race once the instance is shared), and its trailing StructDelete(variablesScope, "$wheels") is a no-op under the current call pattern.

3. Warm model()/controller() lookups pay reflective dispatch on every call

• vendor/wheels/Global.cfc:1169-1181 (model()) and Global.cfc:1144-1163 (controller()) route every warm-cache hit through $doubleCheckedLock (Global.cfc:3) → $invoke (Global.cfc:289) → cfinvoke — two reflective dispatches just to evaluate the one-line $cachedModelClassExists (Global.cfc:917) / $cachedControllerClassExists (Global.cfc:928). model() is the framework's hottest function: called per association, per validation, per row.

4. $resolveInitArguments metadata scan per transient resolution — and it never matches inherited init()

• vendor/wheels/Injector.cfc:290-320 (called from Injector.cfc:177, reached per model row via $createObjectFromRoot) runs getMetaData() on every resolution and inspects only the top-level functions array. Inherited init() lives under extends, so for every app controller/model it returns {} — guaranteed-no-op metadata churn, and the advertised init auto-wiring silently never applies to inherited init().

None of these inputs change during the application lifetime (short of ?reload=true).

Impact

This is the dominant avoidable overhead in the framework. Per materialized row: 1 directory listing, ~19 createObject, ~19 getMetaData, a ~245-function copy, a fresh Plugins+Global instantiation, and a $resolveInitArguments metadata scan. Per request: the ~29-CFC controller+view integration plus another throwaway Plugins. Per warm model() call: two reflective cfinvoke dispatches where a StructKeyExists would do.

Suggested approach (staged — each stage independently shippable, ordered by risk)

Stage 1 — lock-free warm fast path in model()/controller() (low risk; candidate first PR). Before calling $doubleCheckedLock, add a guarded direct lookup, e.g. for model():

if (
    StructKeyExists(application, "wheels")
    && StructKeyExists(application.wheels, "models")
    && StructKeyExists(application.wheels.models, arguments.name)
) {
    return application.wheels.models[arguments.name];
}

(controllers struct for controller(), preserving the params branch that calls $createControllerObject.) Semantically identical to the existing unlocked first check inside $doubleCheckedLock; removes the reflective dispatches per warm call. The full StructKeyExists chain is required for early-bootstrap/reload windows where application.wheels.models may not exist yet, and the change must not bypass $clearModelInitializationCache semantics.

Stage 2 — memoize the integration product per base path. At first use, under a named lock, run one directoryList + createObject + getMetaData pass per base path (wheels.model, wheels.controller, wheels.view) and store a functionName → function-reference map in application scope (same precedent as application.wheels.mixins, which already stores function refs). Rewrite Model.cfc / Controller.cfc $integrateComponents to copy from the cached map into variables/this, preserving the existing collision rules exactly — note they differ per class:

• Model.cfc:562-593 assigns super<name> into variables/this when the method already exists (else-branch), and super-prefixes under $willBeOverriddenByMixin.
• Controller.cfc:165-193 silently skips on collision and only super-prefixes under $willBeOverriddenByMixin (Controller.cfc:195-213).

Apply the identical public-only access filter (cross-engine invariant 7). Must prove per engine that a function reference harvested from instance A and assigned into instance B's variables/this binds to B's variables at call time — the current code already relies on this (refs come from a fresh throwaway component), so behavior should be identical, but verify on Lucee 5/6/7, Adobe 2018/2021/2023/2025, BoxLang.

Stage 3 — reuse the cached application[appKey].PluginObj (Global.cfc:3072) instead of new wheels.Plugins() at EventMethods.cfc:156, Controller.cfc:216, Model.cfc:650, Dispatch.cfc:809, Test.cfc:802. Prerequisites: convert the unscoped $wheels.* scratch writes in $initializeMixins (Plugins.cfc:792-840) to local.-scoped so a shared instance is thread-safe; remove the now-no-op StructDelete(variablesScope, "$wheels"); hoist the EventMethods construction inside the mixins-nonempty guard. Keep the IsDefined("application") guards for Test.cfc/CLI call sites where application may be undefined.

Stage 4 — memoize Injector.cfc $resolveInitArguments (Injector.cfc:290) per component dot-path (init metadata is static per class); invalidate on reload. Whether to also fix the inherited-init() blind spot (walk extends) is a separate behavioral decision — it makes auto-wiring start applying where it silently never did (see review finding DI13).

Benchmark harness (for the issue thread, not specs): time findAll(returnAs="objects") over 500 rows and a 200-request warm controller loop, before/after, on Lucee 7 + Adobe 2023 via tools/test-matrix.sh containers.

Why this needs a design pass (not a drive-by PR)

This is the framework's hottest path with HIGH cross-engine regression surface:

1. Invariant 7 — only public $-prefixed methods integrate; the memoized map must apply the identical access filter or BoxLang will pass while Lucee/Adobe break (precedent: 8f35045a0 made $subscribe* public for exactly this).
2. Function-reference rebinding — copying refs from a cached map into a new instance's scopes must bind to the receiving instance's variables at call time on every engine. Same mechanism the current code uses, but it must be proven, not assumed — especially on BoxLang and Adobe 2021/2023.
3. Invariant 2 — Adobe CF rejects calling function members on application scope. The cached map may only be a storage vehicle (copy-then-call), never called in place; application.wheels.mixins is the existing precedent.
4. Shared PluginObj = shared variables scope — the unscoped $wheels.* writes are a data race once shared; they must be local-scoped first.
5. Collision semantics must not drift — Model's per-instance super-prefix-on-collision differs from Controller's $willBeOverriddenByMixin gate; memoization must preserve each verbatim or plugin override chains (superFoo) break silently.
6. Bootstrap/reload windows — the Stage 1 fast path must guard the full StructKeyExists chain and not bypass $clearModelInitializationCache.
7. No inline closures as constructor named args anywhere in new code (kills entire TestBox bundles on Adobe); no reserved-scope parameter names.
8. Reload must invalidate every new cache (integration map, $resolveInitArguments memo). Lesson from feat(migrator): enrich wheels_migrator_versions with name + applied_at (#2780) #2800: never trust a we-did-this-once flag for state that can be reset out-of-band — re-probe.

Acceptance criteria

• Stage 1: warm model()/controller() return identical objects as before; cold path, bootstrap, and reload windows unaffected; the params branch of controller() still calls $createControllerObject.
• Stage 2: integration product built once per base path under a named lock; per-class collision rules (Model super-prefix-on-collision vs Controller skip + $willBeOverriddenByMixin) preserved verbatim; public-only filter identical to today; map stored as data only (copy-then-call).
• Stage 2: function-reference rebinding proven by spec on Lucee 5/6/7, Adobe 2018/2021/2023/2025, BoxLang before merge.
• Stage 3: $initializeMixins scratch writes local.-scoped; shared PluginObj reused at all five call sites; EventMethods construction hoisted inside the mixins guard; IsDefined("application") guards retained.
• Stage 4: $resolveInitArguments memoized per dot-path; memo invalidated on reload.
• ?reload=true invalidates every new cache.
• Full matrix green: tools/test-matrix.sh --all (and the targeted Adobe 2023 + Lucee 7 MySQL runs during development).
• Before/after benchmark numbers (500-row findAll(returnAs="objects"), 200-request warm controller loop) posted on this issue for Lucee 7 and Adobe 2023.

Source

Internal multi-agent framework review, 2026-06-09 — finding T9 (mixin-integration-memoize), i.e. Top 10 item #9 "Per-request / per-row mixin re-integration and reflective dispatch tax", consolidating detail findings M10, C14, DC12, DC14, DI4, and DI13. Triage classified this as needing design/discussion rather than an autonomous PR; Stage 1 is the one low-risk separable piece that could become a small first PR.

[wheels-bot]

Wheels Bot — Triage

Classified as framework-design (API/feature design question).
Cross-framework research will follow shortly — Rails, Laravel, Django,
and other modern frameworks will be consulted before any path forward
is proposed.

<!-- wheels-bot:triage:2897 -->
<!-- wheels-bot:triage-class:framework-design -->

[wheels-bot]

Wheels Bot — Cross-Framework Research

Question

How do mature frameworks make module/concern/trait composition a one-time boot cost rather than per-request and per-row? The issue documents Wheels re-deriving mixin integration (~245-function copy), throwaway wheels.Plugins, reflective warm model()/controller() lookups, and $resolveInitArguments metadata scans on every model instantiation and every request, and asks for a Wheels-idiomatic adaptation that respects ?reload=true invalidation across Lucee 5/6/7, Adobe CF 2018–2025, BoxLang.

How other frameworks handle this

Framework	Naming	Surface	Trade-offs	Edge cases
Rails	ActiveSupport::Concern, __callbacks (class_attribute), to_prepare	Concerns evaluate once at class load; callback chains compile once; per-instance is normal MRO	Heavy prod boot for zero per-request cost; dev reload via remove_const + to_prepare	CallbackChain#compile guarded by Mutex; reload between requests sidesteps stale-ref
Laravel	bootIfNotBooted + static::$booted[class], $traitInitializers, container singleton, config:cache	Per-class boot flag short-circuits trait reflection after first new; container caches singletons in $instances	FPM cold-start tax; Octane keeps container in memory but stale-singleton bugs	$booted per-worker (no thread issue); scoped() flushed between Octane requests, singleton() not
Django	AppConfig.ready(), _meta, class_prepared, @functools.cache	App registry populated once by apps.populate(); _meta built by metaclass at class definition; descriptors on the class	Each WSGI worker pays boot independently	runserver reload restarts process — no partial invalidation
Phoenix	__using__/1, Plug.Builder, __schema__/1, accumulating module attributes	Compile-time macros accumulate config, emit immutable BEAM functions; per-request dispatch is chained call, zero reflection	Macros obscure stack traces; transferred is the pattern (accumulate → freeze), not the mechanism	mix release ships precompiled .beam; prod never compiles
Spring Boot	ApplicationContext, SCOPE_SINGLETON, BeanPostProcessor, AOT processor, HandlerMethod	Singleton beans cached at boot; @Autowired wired at creation; @Transactional proxy synthesized once	Heavy startup; AOT trades dynamism for build-time wiring	Prototype-into-singleton needs ObjectProvider; DevTools two-classloader restart
Symfony (+1)	CompilerPass, ContainerBuilder → compiled Container, cache:warmup/cache:clear	Mutable builder, immutable compiled Container; warmup writes generated PHP with hardcoded getXxxService(); routes + listeners likewise	Explicit cache:clear in prod (matches CFML ?reload=true); compiled artifacts auditable	Filename-hash collisions under concurrent deploy

Why Symfony as +1: the most explicitly named "compile derived data at warm-up, runtime is array lookup" lifecycle in the PHP/CFML-adjacent world. Mirrors the proposed Wheels shape almost line-for-line, without codegen.

Dominant pattern

Five of six converge on "compute composition once at class-definition or app-boot, store in an immutable structure, gate runtime behind a StructKeyExists-equivalent, expose an explicit invalidation hook (Rails to_prepare, Laravel config:clear, Symfony cache:clear, CFML ?reload=true)". Phoenix moves it to compile-time macros; Spring AOT moves it to build; the rest do it at runtime exactly once. None re-derive composition per request or per row. The Wheels proposal — memoize on first use, gate via StructKeyExists, invalidate on ?reload=true — is the runtime version of this consensus, with direct prior art in application.wheels.mixins (data storage, copy-then-call).

Recommended path for Wheels

Accept the issue's staged plan as-written. Stage 1 maps to Laravel's container $instances short-circuit; Stage 2 maps to Laravel's per-class $booted + Rails's class_attribute callback storage; Stage 3 maps to Spring SCOPE_SINGLETON (the $wheels.* data-race fix non-negotiable); Stage 4 maps to Django's _meta-on-the-class amortization. Naming leans on the application.wheels.mixins precedent: application.wheels.integratedMethods[basePath], application.wheels.initArgsByPath[dotPath].

// Stage 1 — lock-free warm fast path (Laravel-style $instances short-circuit).
// vendor/wheels/Global.cfc, model() and controller().
public any function model(string name = "") {
    if (
        StructKeyExists(application, "wheels")
        && StructKeyExists(application.wheels, "models")
        && StructKeyExists(application.wheels.models, arguments.name)
    ) {
        return application.wheels.models[arguments.name];
    }
    return $doubleCheckedLock(/* existing slow path unchanged */);
}

// Stage 2 — boot-once integration tables (parallel to application.wheels.mixins,
// keyed by basePath, holding {functionName: functionRef}; named-lock memoize).
// vendor/wheels/Model.cfc + vendor/wheels/Controller.cfc.
// Per-class collision rules DIFFER and must be preserved verbatim:
// - Model:      super-prefix on collision (Model.cfc:577-580) AND
//               super-prefix under $willBeOverriddenByMixin (583-587)
// - Controller: silently skip on collision (Controller.cfc:165-193);
//               only super-prefix under $willBeOverriddenByMixin (195-213)

// Stages 3+4 (same pattern):
// 3 — reuse application[appKey].PluginObj at all five new wheels.Plugins() sites
//     after local.-scoping the $wheels.* scratch in Plugins.cfc:792-840;
//     hoist EventMethods.cfc:156 inside the !StructIsEmpty(mixins) guard.
// 4 — memoize $resolveInitArguments per dot-path in
//     application.wheels.initArgsByPath; invalidate on reload.

Lives in: vendor/wheels/Global.cfc (1), vendor/wheels/Model.cfc + vendor/wheels/Controller.cfc (2), vendor/wheels/Plugins.cfc + EventMethods.cfc + 4 other call sites (3), vendor/wheels/Injector.cfc (4). Composes with existing application.wheels.mixins (same data-only, copy-then-call contract); $clearModelInitializationCache + ?reload=true (must invalidate every new key); $willBeOverriddenByMixin (unchanged).

Cross-engine notes

• Invariant 2 — Adobe rejects function-member calls on application. Existing application.wheels.mixins works because refs are data, copied out before calling. Every new cache (integratedMethods, initArgsByPath) must follow the same copy-then-call discipline.
• Function-reference rebinding under variables[name] = src[name]; later this.name() is Stage 2's load-bearing assumption. The current code already does this with throwaway components; the cache extends ref lifetime but call semantics are identical. The BoxLang method-receiver trap in .ai/wheels/cross-engine-compatibility.md applies only to single-statement obj["k"]() — Stage 2 dispatches via this.foo() / variables.foo() which BoxLang re-binds at the call site. A new vendor/wheels/tests/specs/dispatch/IntegrationMemoizationSpec.cfc should pin this on every engine before Stage 2 merges.

Plus: no inline-closure-as-constructor-named-arg in new code (Invariant 5 — catastrophic on Adobe); no reserved-scope parameter names (#11); gate via StructKeyExists on the cached key itself, never a separate "done" boolean (#2800 anti-pattern).

Open questions

• Stage 2 ref-rebinding across all engines under cached refs. Strictly equivalent in CFML semantics but worth one cross-engine spec before merge.
• Should Stage 4 also fix the inherited-init() blind spot (DI13)? Behavior change distinct from memoization — recommend split: memoize first (pure perf), inherited-walk second (separate PR).
• PluginObj sharing under CLI test bootstrap / Test.cfc:802. Outside request lifecycle — keep IsDefined("application") guards; CLI/test can keep paying construction.
• Stage 1 controller params branch — fast path must NOT consume it; returns cached class, never an instance. Easiest review miss.

Confidence: medium

Downgrade fired: the most directly-applicable pattern (Phoenix compile-time macros, Spring AOT codegen) is not portable to CFML — adapted to runtime memoization. Stage 1 is high-confidence and safely auto-proposable in isolation; Stages 2–4 touch the framework's hottest path with HIGH cross-engine regression surface (reporter classified this as needing a design pass), and Stage 2's ref-rebinding assumption deserves spec coverage. Scope any propose-fix attempt to Stage 1 only.

Sources

• https://api.rubyonrails.org/classes/ActiveSupport/Concern.html
• https://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html
• https://guides.rubyonrails.org/configuring.html
• https://laravel.com/docs/11.x/container
• https://laravel.com/docs/11.x/eloquent
• https://laravel.com/docs/11.x/octane
• https://github.com/laravel/framework/blob/11.x/src/Illuminate/Database/Eloquent/Model.php
• https://docs.djangoproject.com/en/stable/ref/applications/
• https://docs.djangoproject.com/en/stable/topics/db/models/
• https://phoenix.hexdocs.pm/Phoenix.Controller.html
• https://plug.hexdocs.pm/Plug.Builder.html
• https://ecto.hexdocs.pm/Ecto.Schema.html
• https://docs.spring.io/spring-framework/reference/core/beans/factory-scopes.html
• https://docs.spring.io/spring-framework/reference/core/aot.html
• https://symfony.com/doc/current/components/dependency_injection/compilation.html
• https://symfony.com/doc/current/service_container/compiler_passes.html

[wheels-bot]

Wheels Bot — Fix proposed

Draft PR: #2914

Spec: vendor/wheels/tests/specs/global/cachedLookupSpec.cfc — failing (4 errors: helper functions did not exist) → passing (7/7).
Implementation: vendor/wheels/Global.cfc — adds $cachedModelLookup / $cachedControllerLookup and wires them into model() / controller(). Stage 1 of the staged plan; Stages 2–4 deferred per the research recommendation.

A human review is required before merge. Reviewer A and Reviewer B will weigh in shortly. Doc updates (MDX guides, .ai/wheels/, CLAUDE.md) are handled separately by bot-update-docs.yml.

[bpamiri]

Wave-2 framework review (2026-06-09) cross-reference — two findings land squarely in this issue's scope:

• DC15 [Medium, perf] — $promoteIncludedGlobalsToThis scans all variables-scope keys with isCustomFunction on every instantiation of every Global-derived component (vendor/wheels/Global.cfc:4171, iterating ~200 inherited UDFs per CreateObject). Paid by Model (per row), Controller, Dispatch, EventMethods, Plugins, and adapters. This is the same Global pseudo-constructor cost already named in this issue's Problem item 2 and Stage 3. Recommendation: memoize the promote-key set once per application; keep the function non-inlined per WheelsTest: custom global helpers added via include don't auto-bind into spec scope (getMetaData misses them) #2790/Reload: bare ?reload=true does NOT re-include app/global/*.cfm files — full re-init requires ?reload=true&password=<admin> #2792.

• DC7 [Low, quality] — Global.cfc is a 4,038-line god mixin: 127 public functions across 11 banner-delimited sections, spanning ~12 distinct responsibilities (cache, tag wrappers, inflectors, etc.). No functional defect — a deliberate long-standing mixin architecture — but the structural decomposition (incrementally extract self-contained clusters into per-concern files while keeping the $-public mixin surface unchanged) should be designed together with the mixin-tax staging here, not done piecemeal, since both touch the same hot-path integration machinery.

Filing these here per wave-2 triage rather than as a separate issue, since the perf half (DC15) is already in scope and the refactor half (DC7) must be co-designed with Stages 2-3 to avoid churning Global.cfc twice.

Source: internal multi-agent framework review 2026-06-09, wave 2 (issues phase). Findings dispatch-core DC7/DC15.

[bpamiri]

Reopening: PR #2914 shipped Stage 1 only (lock-free model()/controller() warm path) but its Fixes #2897 auto-closed this on merge. Remaining scope, verified live on develop by the 2026-06-10 coverage audit:

• Stage 2 — mixin-integration memoization: vendor/wheels/Controller.cfc:4-5 and vendor/wheels/Model.cfc:5 still run $integrateComponents per request / per materialized row.
• Stage 3 — shared PluginObj: vendor/wheels/Model.cfc:672 still constructs new wheels.Plugins().$initializeMixins(variables) per object; vendor/wheels/events/EventMethods.cfc:157 constructs new wheels.Plugins() unconditionally per request though it is only used inside the mixins guard (one-line quick win).
• Stage 4 — $resolveInitArguments memoization: already landed incidentally via fix(di): singleton locking and keying, SemVer space parsing, lazy provider boot #2943 (verified at Injector.cfc:36/352) — drop from scope.
• Orphaned by the auto-close, re-homed here: DC15 per-instantiation $promoteIncludedGlobalsToThis isCustomFunction scan (Global.cfc:4171) and DC7 Global.cfc god-mixin decomposition (design-level).

Cross-links: #2914 (Stage 1), #2943 (Stage 4), #2952 (model SQL layer).

[bpamiri]

Stages 2–4 — design + sequencing (verified against develop @ 345b30dcb, 2026-06-11)

Status check (live-code verification, not issue-text):

• Stage 1 — DONE (perf(global): lock-free warm fast path for model() and controller() #2914, merged 2026-06-10, 24aaa29de). $cachedModelLookup / $cachedControllerLookup live at Global.cfc:968 / :996, wired into model() (:1243) and controller() (:1214). The controller() params branch is preserved — the fast path returns the cached class and $createControllerObject(params) still runs afterward. Pinned by vendor/wheels/tests/specs/global/cachedLookupSpec.cfc (7 specs, including a params-branch regression spec).
• Stage 4 — DONE (fix(di): singleton locking and keying, SemVer space parsing, lazy provider boot #2943, 8e4f50724). Injector.cfc memoizes init parameter names per component dot-path in variables.initParamCache (only NAMES are cached; mappings are matched live, so late registrations still apply). Bonus: $scanInitParameterNames walks the extends chain, so the DI13 inherited-init() blind spot is fixed too — the research comment's "split into two PRs" open question is moot.

Remaining scope (all re-verified present on develop): Stage 2, Stage 3, DC15, DC7. Proposed order is risk-ascending, each independently shippable:

PR A — Stage 3 quick win: hoist the EventMethods construction

EventMethods.cfc:156 constructs local.Mixins = new wheels.Plugins() unconditionally; it is only used inside the !StructIsEmpty(application.wheels.mixins) guard at :219-221. Move the construction inside the guard. Zero semantic change for mixin-free apps; saves one Plugins + Global instantiation (including the $promoteIncludedGlobalsToThis scan) per request. One-line fix + one spec.

PR B — Stage 3 proper: shared PluginObj

$initializeMixins has moved to Plugins.cfc:879-928 (was :792-840). The unscoped $wheels.* scratch writes ($wheels.appKey, $wheels.metaData, $wheels.className) are still there and still land in the Plugins instance's own variables scope — a data race the moment the instance is shared. Plan:

1. Convert the scratch writes to local. scope.
2. Swap new wheels.Plugins().$initializeMixins(variables) for the cached application[appKey].PluginObj (Global.cfc:3301) at the request-lifecycle sites: Controller.cfc:211, Model.cfc:672, Dispatch.cfc:965, and the (now guarded) EventMethods site.
3. Test.cfc:802 keeps constructing — it can run where application is undefined (CLI/test bootstrap); retain the IsDefined("application") guards.
4. Concurrency spec: two targets initialized through one shared instance must not cross-contaminate classification ($wheels.className is the racy field today).

PR C — DC15: memoize the $promoteIncludedGlobalsToThis key set

Global.cfc:4267 (pseudo-constructor call) + :4276-4287 run an isCustomFunction scan over every variables key on every instantiation of every Global-derived component (per model row, per controller, per Plugins instance — so PRs A/B shrink the multiplier first). The include-injected function set is application-lifetime-constant. Memoize the promote-key list in application scope; gate on the cached key itself (never a separate done-flag — #2800 lesson); fall back to the full scan when application is undefined; invalidate on ?reload=true. Open design point: confirm the promotable set is identical across all Global-derived subclasses (the includes live in Global.cfc's body, so it should be) — if not, key per concrete class name.

PR D — Stage 2: integration-product memoization (the big one, last)

• Build once per base path (wheels.model, wheels.controller, wheels.view) under a named lock: one directoryList + per-CFC createObject + getMetaData pass, storing public-only (invariant 7) function refs in application.wheels.integratedMethods[basePath]. Data-only storage, copy-then-call (invariant 2; precedent: application.wheels.mixins).
• Map shape should be an ordered array of {name, ref} entries, not a flat struct — replaying the exact directoryList + metadata insertion sequence is the only way to preserve today's first-integrated-wins behavior if two CFCs in a base path ever export the same name (and struct iteration order is not insertion order on Lucee at scale).
• Rewrite the copy loops preserving per-class collision semantics verbatim — they differ (fresh line refs):
  • Model.cfc:584-614: on collision, assign super<name> into variables/this (:595-601 else-branch), plus super-prefix under $willBeOverriddenByMixin (:605-608).
  • Controller.cfc:160-186: on collision, silently skip (:171-174); super-prefix only under $willBeOverriddenByMixin (:177-181).
• ?reload=true / $clearModelInitializationCache / $clearControllerInitializationCache must invalidate integratedMethods.
• Pre-merge gate: a new vendor/wheels/tests/specs/dispatch/IntegrationMemoizationSpec.cfc proving a function ref harvested from instance A and assigned into instance B's variables/this binds to B's scopes at call time — run on Lucee 6/7, Adobe 2023/2025, BoxLang via tools/test-matrix.sh; plus the before/after benchmark numbers (500-row findAll(returnAs="objects"), 200-request warm loop) posted here per the acceptance criteria.

DC7 — co-design with PR D, land after

Decompose Global.cfc (127 public functions, ~12 responsibilities) only once the Stage 2 machinery has settled, so the hot-path files churn once. Extraction must keep the $-public mixin surface byte-identical (invariant 7).

Open questions

1. PR D map shape: ordered-array replay (proposed) vs. proving no duplicate exported names across CFCs per base path and using a flat struct.
2. PR C cache key: single app-wide promote list vs. per-concrete-class — needs a quick probe of whether any subclass injects extra body-scope functions before Global's pseudo-constructor completes.
3. Should Dispatch.cfc:965 / Test.cfc:802 ever share PluginObj, or stay construct-per-use (low frequency, bootstrap-sensitive)? Current lean: leave them.