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.
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.
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.
`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.
Backup code validation is case-sensitive due to the use of indexOf(). This causes validation to fail if a user enters uppercase hex characters, as backup codes should be case-insensitive for a better user experience.
The diff converts the outer cancellation lookup from `find` to `filter` and loops over every calendar reference, but the recurring branch still resolves a single reference with `references.find((ref) => ref.type.includes('_calendar'))` and iterates only the organizer's credentials. For each remaining occurrence only the first reference is deleted and only with the organizer's credentials, so team members' calendar events survive the cancellation.
`sendAddGuestsEmails` takes no event-type metadata and unconditionally sends to the organizer, every team member and every attendee, while every other booking-lifecycle sender in the same file gates on the helpers that read `disableStandardEmails.all.host` and `.attendee`. The handler already loads the event type, so the metadata is in hand and simply not passed, and an organizer who disabled standard emails still has them sent.
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.)
`resetAndMaybeDumpStats` copies and re-makes `a.stmts` but the diff's new per-fingerprint `a.txns` map is neither transferred to the copy nor cleared. Transaction statistics therefore survive every reset, are never handed to the reported-stats sink, and accumulate one entry per distinct transaction fingerprint for the lifetime of the node.
The new image-set loader offers a "Pad" resize option whose branch is identical to "Stretch": it calls the same full resize to the target width and height, with no aspect-preserving thumbnail and no border fill. A user who loads a folder of differently sized images and picks "Pad" to keep aspect ratio gets every image whose size differs from the first one non-uniformly squashed, silently corrupting the training data, with nothing reporting that the chosen option behaved the same as "Stretch".
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.
`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 new permission-denial cache key concatenates namespace, user, action, name and parent with underscores, but underscores are legal in Grafana UIDs, so distinct tuples collide -- a resource named `alerts_prod` in folder `team` produces the same key as `alerts` in folder `prod_team`. A denial recorded for one then short-circuits the check for the other, returning not-allowed without evaluating permissions for the cache lifetime.
`useAllAlertRuleAbilities` is rewritten to delegate to an implementation that hardcodes `const isFederated = false`, deleting the real `isFederatedRuleGroup(rule.group)` check that fed `immutableRule`. Federated Mimir rules are therefore treated as editable: the rule list renders an Edit button that opens the rule editor, where pre-diff the ability was NotSupported and no button appeared.
`TestNewClaimInfoFromClaim` and `TestNewClaimInfoFromState` assert with an inverted condition: `if reflect.DeepEqual(result, test.expectedResult) { t.Errorf(...) }`. That reports a failure only when the result MATCHES the expectation, so the tests never validate the constructor and pass vacuously (and `expectedResult` is left nil). The fix inverts the check to `if !reflect.DeepEqual(...)`.
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 cacher delegator's `GetList` adds an unconditional `if errors.IsResourceExpired(err) { return c.storage.GetList(...) }` fallback to etcd. When the cache snapshot is nil the cacher returns `ResourceExpired`, so consistent paginated LISTs silently fall back to etcd instead of being served from cache, defeating the feature and adding etcd load. The fix gates that fallback behind the cache-snapshot feature flag.
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.
The textarea XML schema is changed to declare the placeholder property as `placeholder_text`, but the textarea XML parser, which the change does not touch, still matches only the attribute name `placeholder`. XML written against the updated schema, such as `<lv_textarea placeholder_text="Type here"/>`, matches no branch in the parser's attribute chain, so `lv_textarea_set_placeholder_text` is never called. The attribute loop has no unknown-attribute warning, so the placeholder is dropped silently.
`grid_update` gains an early return when the grid calculation fails, but the calculation has already allocated its row arrays by then and the early return skips the free routine. A grid container that has a row descriptor but no column descriptor, on itself or its parent, gets `c->y` and `c->h` allocated in the row pass and then fails the column pass, leaking both arrays on every layout refresh. Calling the existing free routine at that point is not by itself a safe fix, because the struct is not zeroed on every failure path.
`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 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.)
In imageOptimizer's internal-request path, `if (!mockRes.statusCode)` can never be true for any real HTTP status code (`mockRes.statusCode` starts at 200 and is only ever set to other truthy numbers like 404/500 by `handleRequest`), so the intended check for a failed internal response never fires. The old code additionally forwarded the upstream status via `res.statusCode = mockRes.statusCode`; this diff removes that forwarding entirely, so an internal 404/500 is masked behind an eventual 200 (until a secondary content-type check happens to catch it).
`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.
OAuth state uses pipeline.signature (static) instead of a per-request random value
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.
The new `HasOrderSpecified()` type-switches over the trace, log, metric and formula query types and omits `QueryBuilderTraceOperator`, which carries its own `Order` field and is a first-class member of the same pipeline. `applyDefaultSort` is therefore true for a trace-operator query that did specify an order, and the scalar formatter re-sorts by the first aggregation -- the descending re-sort this PR exists to suppress.
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.