valid_entries() uses a bare truthiness check (`if e`) but its docstring promises "the non-empty entries." This silently drops legitimate falsy-but-non-empty values too -- 0, 0.0, False, [], {} -- not just "" or None. Any caller passing counts, scores, or booleans loses valid entries with no error raised.
commit() gates the staged navigation on truthiness (`if (state.pendingMpaNavigation)`), so an empty-string url is indistinguishable from the `null` initial state and the redirect is silently skipped. Before the diff the reducer called navigate(action.url) directly with no gate, so navigate("") ran. `Action.url` is typed `string` with no non-empty constraint, so dispatch({ type: "redirect", url: "" }) type-checks at the public boundary. Same falsy-vs-absent collision as t1-py-filter-shifts-pairing d2, introduced here by the new staging step.
The diff adds `await prisma.workflowReminder.update(...)` inside the loop's catch block, which previously held only a `console.log` and so could not fail. Nothing wraps the loop: the handler's only try/catch is the inner one, and the `for` at line 55 closes with no surrounding handler, so a throw from that update escapes the loop and the handler, and `res.status(200).json(...)` is never reached. One reminder's DB failure now aborts the whole batch, where before each iteration was isolated. Reachable: Prisma's update raises P2025 when the row is gone, which this diff makes likelier by adding a deleteMany branch that can remove rows a concurrent cron run is processing. Independent of d2 and d3 -- d2 is the missing `method: SMS` filter on deleteMany, d3 is the locked-account misclassification, and fixing either leaves this failure path in place. Medium rather than high: the unreached reminders keep `scheduled: false` and fall inside the query's `scheduledDate <= now + 7 days` window, so the next cron run picks them up. The loss is fault isolation and a deferred batch, not dropped reminders, and it only reaches a user when a send time falls inside the gap before the next run.
The new immediateDelete branch of deleteScheduledEmailReminder cancels the scheduled email at SendGrid on the spot, and three new call sites use it (rescheduling in handleNewBooking, workflow and workflow-step deletion in workflows.tsx). Each such cancellation stays pending in SendGrid's scheduled_sends until the email's send time, up to 72h ahead, and SendGrid allows only 100 pending cancellations: the limit this PR's deferred, cron-driven cancellation exists to stay under. Under steady rescheduling the immediate cancellations fill it, after which cancellations are rejected (and only logged), both the immediate ones and the cron's deferred ones, so reminders for rescheduled and cancelled bookings are sent anyway.
Statement IDs are built with `h := fnv.New128()`; the stdlib hash/fnv constructor heap-allocates a hash object on every statement, and the ID is constructed even when not required. On hot SQL paths this is a measurable allocation/throughput regression (the fix's microbenchmarks show kv95 +3.42%). The fix uses a lightweight value-type FNV and only builds the ID when needed. (Large-diff stress case: ~2.8k lines, 14 files.)
recordTransaction unconditionally records CommitLat via getCommitLatency() for both txnCommit and txnRollback, but sessionStartTransactionCommit/sessionEndTransactionCommit are only set in commitSQLTransaction and never reset between txns, so rolled-back transactions record a stale (prior commit) or zero commit latency into their CommitLat stats.
Passing 80% as the dimensions can fail for animated GIFs when allow_animated_thumbnails is true, since the animated path uses gifsicle --resize-fit which expects WxH geometry, not a percentage; downsizing would then silently fail.
The new downsize loop tests `tempfile.size` and passes the same expression as the filesize argument to `Upload.create_for`, but the conversion ends in an image optimizer that atomically replaces the file. After the first pass the open Tempfile descriptor refers to an orphaned inode, so the reported size stops tracking the file on disk: the loop condition is frozen at the post-first-pass value and the upload is then rejected as too large by the validator even though the file has been shrunk well under the limit.
NoMethodError before_validation in EmbeddableHost
The new plural-ID hydration branch in `_hydrateEmbedded` (added alongside the existing singular path) maps a list of ids through `_lookupSubType` and assigns the result unconditionally: `obj[self.pluralize(subType)] = hydrated || []`. `_lookupSubType` returns `undefined` for an id whose root collection or specific id isn't found; since Array.prototype.map always returns an array, `hydrated` is always truthy and the `|| []` fallback never fires, so the resulting array can contain literal `undefined` entries (e.g. [ModelObj, undefined, ModelObj]). This is the reverse of the existing singular path, which correctly guards with `if (hydrated)` before assigning.
`remove_member` deletes the association with `group.users.delete(user_id)`, which for a has_many-through with no `:dependent` resolves to a raw `delete_all` and never instantiates the join model, so the `counter_cache` on GroupUser never decrements. The sibling add path uses `group.add(user)`, which does instantiate and increments, so `groups.user_count` drifts upward monotonically and is rendered to admins and returned by the group endpoint.
`ZUploadPrivateFileRequest` gains `elementId` as a required string with no `.optional()` and no default, and its single consumer returns 400 on parse failure before destructuring the field into the signed-URL path. The published contract is not updated: the OpenAPI reference still documents the endpoint as requiring only surveyId, fileName and fileType, and the diff does not touch it.
`isScopedPrivateUploadUrl` rejects anything that is not exactly the new eight-segment shape (`if (segments?.length !== 8) return false`), and `validateClientFileUploads` fails on that. Legacy private upload URLs are four segments, so a response created before the deploy can never be updated afterwards. The same diff's `parseStorageFileUrl` is deliberately tolerant, so the delete path stays backward compatible while the validate path does not.
The claimInfo-cache tests seed their "item in cache" fixtures under the key `claimName + namespace`, but the cache itself keys entries on `namespace + "/" + claimName`. The mismatched key means the seeded entry is never found, so the `get`/`delete`/`contains` tests pass vacuously without exercising the real lookup. The fix keys the fixtures on `namespace + "/" + claimName` to match the cache.
The diff removes the fail-fast `IllegalStateException` that rejected multiple crypto providers on the classpath, replacing it with an order-based sort, a debug log and `foundProviders.get(0)`. All three real providers return the same order value, and `Stream.sorted` is stable, so a tie is resolved by ServiceLoader enumeration order: on a deployment carrying both the default and the FIPS provider, which one is selected depends on classpath ordering rather than configuration.
Both group list endpoints drop the hoisted global permission check (`boolean canViewGlobal = groupsEvaluator.canView()`) and filter with a per-group `groupsEvaluator::canView`. Under fine-grained admin permissions v2 that per-group call falls through to a resource lookup and a full uncached policy evaluation, so one evaluation becomes one per group; the subgroup endpoint is worse because it fetches subgroups unbounded and paginates only after filtering.
In verifySafeHtml the prefix length `start` and suffix length `end` are computed independently with no `start+end <= value.length()` guard, so when the OWASP sanitizer balances mis-nested allowed tags (e.g. `<p><b>x</p>` → `<p><b>x</b></p>`) the overlapping prefix/suffix make `value.substring(start, value.length()-end)` have beginIndex > endIndex, throwing StringIndexOutOfBoundsException exactly on the illegal-HTML case it should report.
The client-credentials grant builds its token through `tokenManager.responseBuilder(...).generateAccessToken()` directly, bypassing the shared response path where the diff sets `Constants.GRANT_TYPE` on the client session context. `initToken` then reads that attribute, finds it null and substitutes the unknown marker, so every client-credentials token id encodes `na` rather than the shortcut the diff registers for this grant. Every other direct-responseBuilder path in the PR was updated; this one was missed.
ConditionalPasskeysEnabled() called without UserModel parameter
`SourceUtils.findMatchingChild` iterates a folder's children and returns the first name match without excluding directories (no `isFolder()` / file-vs-folder check). A directory whose name equals the class name (e.g. a package dir `Test/` next to `Test.java`) is returned as the "source file", so go-to-source resolves to a folder instead of the file. The fix skips folders when matching.
The new source-action code generators emit commands with a hardcoded `nbls.`-prefixed name (e.g. `new Command(..., "nbls.generate.code", ...)`) instead of routing the name through `Utils.encodeCommand(command, client.getNbCodeCapabilities())` the way the sibling generators do. Any LSP client whose capabilities use a different command prefix gets a dead source-action menu. The fix runs the command name through `encodeCommand` so it respects the client's prefix.
The image-optimizer move to response-cache dropped the maxAge argument to sendResponse and hardcoded the cached-image header to `public, max-age=0, must-revalidate` instead of `max-age=${maxAge}`. The computed upstream/minimumCacheTTL maxAge is no longer propagated, so every optimized image returns max-age=0 and CDNs/browsers in front of a single instance stop caching, inflating origin load. (Large-diff stress case: ~3.6k lines, 15 files.)
`unstable_revalidate`'s new try/catch around the revalidation fetch discards the real error entirely: both a network failure and a non-OK HTTP response from the revalidation endpoint are collapsed into an identical, opaque `Failed to revalidate ${urlPath}` error with no status code, so callers can no longer distinguish a network outage from a 404/500 returned by the endpoint being revalidated.
The pages template sets `isIsrFallback` for an ungenerated path of a `fallback: true` route and clears it only for bots, minimal mode or an existing cache entry, never for on-demand revalidation. Base-server forced a blocking render when `isOnDemandRevalidate` was set. So `res.revalidate('/posts/new')` for a path not yet generated now returns the build-time fallback shell with its cache control deleted: nothing is stored, yet the response carries `x-nextjs-cache: REVALIDATED`, so the revalidate call reports success without generating the page.
The app-page template adds an early `if (isSSG && prerenderInfo?.fallback === false && !isPrerendered) throw new NoFallbackError()` that runs before draft mode or minimal mode is considered. The base-server check it replaces skipped preview/draft mode and minimal mode, and the sibling pages and app-route templates keep a `!isDraftMode` guard. A draft-mode request for a path of a `dynamicParams = false` app page that was not prerendered now returns 404 instead of rendering on demand, which breaks CMS preview of unpublished pages.
The new `upsampled_count` SnQL function in `DiscoverDatasetConfig` (datasets/discover.py) is `toInt64(sum(sample_weight))` with no fallback for a missing weight. Snuba stores `sample_weight` as Nullable(Float64) and writes NULL for any error event that carried no client sample rate, and `sum` skips NULLs. Once events-stats rewrites `count()` to `upsampled_count() as count` for an allowlisted project set, every unweighted event counts as 0 instead of 1, so error charts undercount, and a bucket holding only unweighted events returns NULL instead of its event count.
In applyFormulas (pkg/querier/postprocess.go), the new RequestTypeScalar branch calls applySeriesLimit on the result of processScalarFormula, but that result's Value is a *qbtypes.ScalarData while applySeriesLimit type-asserts result.Value.(*qbtypes.TimeSeriesData) and returns the result unchanged when the assertion fails. So for scalar/formula query results the call is effectively dead code: the configured order-by and limit on the formula are silently ignored, and scalar formula results come back unordered with no limit applied.
In VisitComparison's IN-clause branch, `case []any: values = varValues` passes an empty slice straight through when a variable resolves to []any{}. condition_builder.go's FilterOperatorIn handler then builds conditions := []string{} from an empty values, and sb.Or(conditions...) with zero arguments returns an empty string (confirmed in the vendored huandu/go-sqlbuilder@v1.35.0 source: Or returns "" when len(orExpr) == 0 after filtering). The generated WHERE-clause fragment for that condition vanishes rather than encoding "no rows match", so a filter meant to exclude everything silently matches all rows instead.
chSQLQuery.renderVars substitutes variable values into the raw ClickHouse query string via strings.Replace BEFORE parsing that string as a Go text/template (tmpl.Parse(query) / tmpl.Execute). If a variable's own VALUE contains the Go template delimiters {{/}}, the substituted text is then re-interpreted as a live template action in the second stage -- e.g. a variable value of "{{.SIGNOZ_START_TIME}}" gets replaced with the numeric start timestamp rather than being treated as literal text, silently changing the rendered query; a malformed template fragment (e.g. "{{.") causes template.Parse to fail, surfacing as an opaque HTTP 500.
parseFieldKeyRequest renames the field-key search parameter from ?name to ?searchText (r.URL.Query().Get("name") -> r.URL.Query().Get("searchText")). parseFieldValueRequest calls parseFieldKeyRequest internally (now reading ?searchText) and separately reads ?name for a different purpose (keySelector.Name, overriding what the key-request set). Any existing caller using GET /api/v1/fields?name=service_name to filter the field-key list gets back all keys instead of a filtered set -- the ?name parameter is simply ignored for that endpoint, a breaking API change with no version bump.
rewriteExpression replaces all quoted string literals in the HAVING expression with __QUOTED_N__ placeholders BEFORE matching column-map keys against it. A key like countIf(level='error') (itself containing a quoted literal) is turned into a regex built from its raw, unprotected form, so it can never match the already-placeholder-substituted expression -- e.g. a HAVING clause countIf(level='error') > 10 reads as countIf(level=__QUOTED_0__) > 10 after quote-protection, and the \bcountIf\(level='error'\) pattern silently fails to match, so the rewrite (and the __result_N substitution downstream code depends on) is silently skipped.
getProjectStats calls .collect() on all tasks for a project, loading every matching document into memory; for projects with many tasks this can exceed Convex's read/memory limits and crash the query.
`checklist` is stored as a growing `v.array(...)` on the task document, so its size is bounded by Convex's 1 MB per-document limit rather than by anything in the code: once a task accumulates enough items the patch in `addItem` fails and the task can no longer be written. Every toggle also rewrites the whole array, so write cost grows with the item count, and individual items cannot be indexed or queried. The fix is a separate `checklistItems` table keyed by `taskId`. Stated as the document-size limit rather than as a design preference, because that is the hard ceiling that makes writes fail and is what expectations.md records as the pass condition ("risks hitting the 1MB document size limit").
`toggleItem` declares `index: v.number()`, which accepts any float and NaN, and guards with `if (args.index < 0 || args.index >= checklist.length)`. Both comparisons are false for NaN, and 0.5 sits inside the range, so the guard passes, `checklist[args.index]` is `undefined`, and reading `.completed` off it throws an unhandled TypeError. Reachable from the public mutation API, which is what the validator exists to constrain.
The new tabview tab-button create callback reads the optional `index` attribute and passes the result straight to the XML integer parser. A missing attribute makes the lookup return NULL and the parser dereferences it immediately, so any XML using the tab-button element without an explicit index crashes once the tabview already has a tab, instead of falling back to the first tab.
The filename language guesser reuses one `checked_tag` latch for both the hearing-impaired (`sdh`/`hi`/`cc`) and the newly added `forced` suffix, so only the last dot-separated suffix is ever tested as a tag. For a subtitle named `movie.en.sdh.forced.srt` the parser strips `forced`, sets the latch, and then reads `sdh` as the language, returning language "sdh" with the hearing-impaired flag unset. With the suffixes the other way round, `movie.en.forced.sdh.srt`, the six-letter `forced` fails the primary-subtag length check, so no language is found and the forced flag is lost. The wrong language reaches real tracks through subtitle autoload and sub-reload.