The diff makes normalize_tags() lowercase tags — a plausible normalization. But the unchanged consumer access.is_admin() compares against the capitalized literal "Admin", so after lowercasing the membership test never matches and every admin silently loses admin status. No exception is raised; the change looks like a clean improvement in isolation and the break is only visible through the unchanged consumer access.py.
EventManager.ts:170 now writes credentialId: undefined for video booking references (was result.credentialId from videoClient.ts:78), so handleCancelBooking.ts:491's `if (bookingVideoReference.credentialId)` guard is always false and the external video meeting is never deleted on cancellation.
The new date-override block is inserted ahead of the availability test that ends `checkIfIsAvailable` (`return busy.every(...)`). When a slot falls inside an override window the `find` callback sets `dateOverrideExist` and returns undefined, so `.find()` matches nothing, the outer branch is skipped, and `if (dateOverrideExist) return true` reports the slot bookable without ever evaluating `busy`. A slot inside a date override is offered even when it collides with an existing booking.
TopicRetriever fetches the embed/feed URL with `open(url).read` (Readability) and `open(SiteSetting.feed_polling_url)`. The only guard is `invalid_host?`, which pins the initial referer/embeddable_host; open-uri transparently follows HTTP redirects, so a whitelisted host returning a 3xx to an internal address (link-local 169.254.169.254, a private IP, or a localhost admin port) reaches it. This is a redirect-based SSRF that the host whitelist does not cover.
The TopicEmbed.import method is susceptible to a NoMethodError if the contents parameter is nil when attempting to append a string, and an XSS vulnerability due to unescaped url interpolation in the generated HTML.
Because flusher processes are created via multiprocessing.get_context('spawn').Process, they are instances of multiprocessing.context.SpawnProcess, which on POSIX is not a subclass of multiprocessing.Process, so this isinstance check will always be false and hung processes won't be killed here.
SimpleQueueProcessingStrategy.close()/join()/terminate() (queue_consumer.py:335-342) call queue_pool.shutdown() on the factory-shared FixedQueuePool during arroyo's partition-revocation rebalance, so the next create_with_partitions reuses the now-shut-down pool whose work_queue.put() raises queue.ShutDown — swallowed by submit()'s broad except, which then marks offsets complete, silently dropping all messages and committing their offsets after the first rebalance.
When requests are authenticated with API keys or org auth tokens (which have user_id=None), organization_context.member is None. Line 71 attempts to access organization_context.member.has_global_access without checking if member is None, causing an AttributeError crash when optimized_pagination=true is used, even though the request passed all permission checks with valid org:write scope.
RouteCard() is changed to send Amex to the Adyen gateway instead of Stripe — a plausible routing tweak with no local smell. But the unchanged consumer capabilities.go records that this service's Adyen integration only handles Visa and Mastercard, so Amex payments routed there can no longer be processed. Whether the legacy gateway supports Amex is a codebase-specific fact stated only in the unchanged Supports(); a diff-only reviewer has no basis to know the reroute is wrong.
The change narrows shouldShowSyncColumns() with `&& conn.supportsColumnSelection`, which is correct for the column-selection control. But the unchanged consumer wizard.ts uses that same gate to show the sync-method and primary-key controls too. For any connector that does not support column selection, those two controls now silently disappear, so the user can no longer choose incremental vs full-refresh sync. The fix is a separate gate for column selection.
The change adds the assertSameEnv() environment-scoping guard to the create() and update() mutations, but the sibling remove() on the same controller is left unguarded. An API key scoped to one environment can therefore delete an integration in another environment of the same org (a cross-environment IDOR). The vulnerable line is the unchanged remove(): the diff shows the guard being added to its siblings, not to it.
sameElidedPrefix(newSpan.Key, lastFile.Span.EndKey, ...) is structurally always true in the contiguous-extend path, since isContiguousSpan requires newSpan.Key == lastFile.Span.EndKey by definition -- comparing ElidedPrefix(X) to itself. The guard therefore cannot fire on the exact path it exists to protect: extending a manifest file across a contiguous span whose elided prefix differs from s.elidedPrefix silently mislabels the entry's key-strip prefix, corrupting restore for ordinary backup shapes (a table's span ending where the next table's begins). Distinct from d1 -- same function, different mechanism. The sibling file_sst_sink.go compares spanPrefix against s.elidedPrefix directly and does not have this bug.
getDeleter re-acquires when `!timestamp.After(expiration)` (timestamp <= expiration), which is the lease's valid range, so it re-leases every call while valid and reuses the expired descriptor (setting a past UpdateDeadline) once timestamp > expiration — inverted relative to hasExpired's `expiration.LessEq(timestamp)`.
This PR renames the private storage download/delete route from a single-segment [fileName] dynamic parameter to a catch-all [...filePath], specifically so it can also serve the newly introduced /storage/{workspaceId}/private/surveys/{surveyId}/elements/{elementId}/{file} scoped upload paths (per the PR's own description: "Scope new private upload URLs under .../surveys/{surveyId}/elements/{elementId}/..."). Both the nested route shape and the underlying storage key scheme for element-scoped uploads are new in this diff. Routing these newly introduced, more sensitive per-response upload files through the SAME entry point -- still gated only by the pre-existing, role-blind hasUserWorkspaceAccess (see d1) -- exposes them to billing-role users for the first time. This is a diff-attributable widening of exposure, distinct from d1's own (pre-existing, unchanged) check logic: unlike d1, this defect is genuinely introduced by the diff and should not be excluded from headline scoring.
Passing `nextConfig: __NEXT_HAS_REWRITES ? undefined : nextConfig` to getNextPathnameInfo was meant to preserve the locale prefix, but disabling the whole config also disables basePath stripping. The `/_next/data/<buildId>/...` prefix is never removed, and on a catch-all route the route regex overwrites router.query.<param> with the leftover data-URL segments, producing malformed URLs and 404s when basePath + rewrites + middleware + dynamic routes combine.
The response-handling refactor builds the /_next/data JSON page response as Buffer.from(JSON.stringify(result.value.pageData)). RenderResult.isDynamic decides static-vs-dynamic via `typeof this.response !== 'string'`, so a Buffer is misclassified as a dynamic stream; sendRenderResult then skips Content-Length and ETag and falls back to Transfer-Encoding: chunked, breaking CDN-side compression for self-hosted Pages Router deploys. The fix deletes the Buffer.from wrapper. (Large-diff stress case: ~3k lines, 22 files.)
In app-page.ts the resume-render branch calls getFallbackRouteParams(pathname) where pathname (parsedUrl.pathname, interpolated in prepare()) is the resolved concrete path with no [param] segments, so getRouteRegex finds no dynamic keys and returns null; it should use normalizedSrcPage (the route pattern) as the sibling PPR-fallback call and the original base-server pathname (match.definition.pathname) did, breaking PPR fallback-shell param postponement for dynamic routes when renderFallbackShell is set in production.
In the app-route template's on-demand-revalidate path, responseGenerator correctly writes a real 404 response (res.statusCode = 404; res.end(...)) and returns null when isOnDemandRevalidate && revalidateOnlyGenerated && !previousCacheEntry. Back in handleResponse, because this route is ISR-eligible (isIsr is true -- it's determined solely by prerender-manifest membership, independent of the on-demand-revalidate flags, and on-demand revalidation is inherently an ISR-only feature), the `if (!isIsr) return null` short-circuit is skipped, and cacheEntry?.value?.kind !== CachedRouteKind.APP_ROUTE (true, since cacheEntry is null) throws an "Invariant: app-route received invalid cache entry" error -- even though a valid 404 HTTP response was already sent to the client. Because isIsr is true, the surrounding catch re-throws this spurious error rather than swallowing it, propagating it up through base-server onto an already-ended response.
With `trailingSlash: true`, the new handler templates (app-page.ts, app-route.ts, pages.ts) take `resolvedPathname` from the request URL, which base-server now rebuilds from the raw `initURL` and which still ends in a slash. None of them calls `removeTrailingSlash`, which base-server applied before its cache-key and prerender lookups. The build writes prerender-manifest keys without the slash, so every lookup misses. For app-page, a prerendered page on a `dynamicParams = false` route is taken to be unlisted and throws NoFallbackError (404), and the ISR cache key becomes `/blog/a/`, so the prebuilt output is never served.
The re-implemented Server Action reducer now rejects the action's promise with a redirect error for every redirect, external ones included, where it previously resolved them, and builds that error's URL with createHrefFromUrl, which keeps only the path and query, so an external URL loses its origin. Called from a form action or useTransition, React catches the handled error and the external navigation that handleExternalUrl staged (mpaNavigation) goes through. Called outside a React scope, such as a plain onClick, the rejection reaches the app router's unhandledrejection handler, which pushes the same-origin path; that navigation supersedes the external one, so the redirect to the external URL never happens.
The PR added API-key environment scoping to only the create and update integration routes. The sibling mutations removeIntegration, setIntegrationAsPrimary, and autoConfigureIntegration on the same controller were left unscoped, so an API key from one environment can delete, re-prioritize, or auto-configure integrations in another environment of the same org (cross-environment IDOR).
The change narrows shouldShowSyncColumns with `&& selectedConnector.supportsColumnSelection`, correct for column-selection but the same flag also gates the Sync-method, Sync-field, and Primary-key columns. supportsColumnSelection is false for all non-SQL sources (Stripe, Hubspot, REST), so those three controls silently disappeared for every non-SQL source during table setup.
A new usage-report query runs raw `FROM logs` through sync_execute() on the logs cluster. HogQL resolves its `logs` table to the physical `logs_distributed` table, and production's logs cluster has no table named `logs`: the `logs` Distributed table that migration 0214 creates exists only in local and test schemas, which is why the PR's test passes. In production the query fails, and since the new query runs unconditionally it aborts the whole usage-report run that feeds billing (reverted the next day in #60611).
In listWithTeamHandler (packages/trpc/server/routers/viewer/eventTypes/listWithTeam.handler.ts), this PR adds `AND "public"."EventType"."teamId" IS NULL` to the WHERE clause of Part 1 of the raw SQL UNION query. Part 1 previously returned every EventType owned by the current user (`userId = currentUser`); the new condition restricts it to non-team event types only. Team event types are then expected to come from Part 2, which discovers them via an INNER JOIN on Membership. But a team event type whose `userId` is set to the current user while that user has no Membership row for the team falls through both branches: Part 1 excludes it (teamId is not null) and Part 2 excludes it (no Membership). The result is that such owned team event types silently disappear from the listing, breaking the event-types view for owners-without-membership.
In useBookings, this PR renames the instant-booking query parameter from bookingId (a number) to bookingUid (a string), but the getInstantBookingLocation query is still gated only on `enabled: !!bookingUid` with no isInstantMeeting guard. A non-instant "additional seats" booking flow carries a bookingUid in the URL (Booker store setSeatedEventData), so the query now fires for it; when the existing booking's metadata has a videoCallUrl, RedirectToInstantMeetingModal pushes the booker to that video page, and otherwise an error toast shows. Either way the seat cannot be booked. Before the rename the value was read as `parseInt(getQueryParam("bookingId") ?? "0")`, which was 0 (falsy, query disabled) on those URLs, so the rename is what newly triggers the path. The fix gates both the query and the redirect effect on isInstantMeeting.
The informer transform `trim` calls `accessor.SetManagedFields(nil)` unconditionally on every resync, mutating the object that lives in the shared informer cache. Because that cached object is read concurrently by other informer consumers, the unconditional in-place mutation is a data race that can panic kube-controller-manager / scheduler. The fix guards it (`if accessor.GetManagedFields() != nil`) so the transform is idempotent and does not rewrite shared state when already trimmed.
In `prepareResources`, the branch that handles an already-prepared claim (`if claimInfo.isPrepared()`) does `return nil` instead of `continue`. Because this runs inside the `for ... range pod.Spec.ResourceClaims` loop, the first already-prepared claim short-circuits the whole loop and the pod's remaining ResourceClaims are never prepared. The fix changes `return nil` back to `continue`.
Limited consistent LISTs bypass the watch cache and hit etcd. For a consistent read the delegator sets `opts.ResourceVersion` to the current etcd RV, so in `watchCache.list` the new "legacy exact match" branch (`Limit > 0 && len(opts.ResourceVersion) > 0 && opts.ResourceVersion != "0"`) now matches and routes the request to `listExactRV`. With `ListFromCacheSnapshot` off (its default) the snapshot store is nil, so `listExactRV` returns `ResourceExpired` and the delegator falls back to etcd. The net effect is that in the default config every consistent LIST that carries a limit (e.g. `GET /pods?limit=500`) now bypasses the cache and queries etcd directly; even with snapshots enabled it drops the index-based prefiltering that `listLatestRV` would apply.
Continue requests are served from a cache snapshot without a freshness wait, so a lagging cache returns a stale, incomplete page. A continue request carries no explicit ResourceVersion (forbidden), so `Cacher.GetList` computes `listRV = 0` and `WaitUntilFreshAndList` does not block; the serve path then calls `listExactRV(key, continueKey, continueRV)` -> `snapshots.GetLessOrEqual(continueRV)`, which returns the greatest snapshot <= continueRV even when the cache has not reached continueRV, and labels the response `ResourceVersion = continueRV`. In an HA cluster a continue token minted by a fresh apiserver A and routed to an apiserver B whose watch cache lags continueRV yields an older snapshot's page mislabeled at continueRV, silently dropping objects created in (snapshotRV, continueRV].
The new pod index `AddPodControllerUIDIndexer` / `PodControllerUIDIndex` keys solely on the owning controllerRef's UID (`[]string{string(ref.UID)}`), ignoring namespace, kind, and name. Controllers (DaemonSet/ReplicaSet/Job/StatefulSet) that look pods up through this index can claim the wrong pods when a stale or duplicated ownerReference UID collides. The fix re-keys the index on the full (namespace, kind, name, uid) tuple.
In the new signals auto-start path (_resolve_autostart_assignee in products/signals/backend/auto_start.py), candidate users are filtered with User.objects.filter(..., teams__id=team_id). User.teams is a @cached_property on the User model, not an ORM relation, so this lookup raises Django FieldError ("Cannot resolve keyword 'teams' into field") every time the path reaches the query. The exception is swallowed upstream, so report generation keeps working but the auto-start path silently creates zero implementation tasks. It is cross-file because the teams cached_property lives in the user model file while the broken filter is in the changed auto_start.py code.
In pkg/querier/postprocess.go the new prepareFillZeroArgsWithStep builds the fillZero function args as {req.Start, req.End, step} where step is computed in milliseconds (query.StepInterval.Duration.Milliseconds()) but req.Start/req.End are not guaranteed to be in milliseconds at runtime (callers may pass nanosecond-resolution timestamps). funcFillZero requires all three args in the same unit and loops from start to end by step appending one point per iteration; when start/end are nanoseconds and step is milliseconds the iteration count is ~10^6x too large, so the fill-zero path allocates an enormous slice of zero points and blows up memory / OOMs the query service.
In pkg/querybuilder/where_clause_visitor.go the new variable-recognition blocks in VisitComparison slice var_ with var_[1:] (to retry the variable lookup without a leading '$') guarded only by a string type assertion: "if var_, ok := value.(string); ok" / "if var_, ok := values[0].(string); ok". An empty string passes that assertion, and var_[1:] on "" panics with "slice bounds out of range [1:0]", crashing the request goroutine / query service. It is reachable: a filter expression value of '' (empty quoted literal) flows through VisitValue -> trimQuotes("''") -> "" into both the single-value comparison path and the IN/NOT IN path.
The new eventDecoder builds each event's row from `getPhysicalColumnsSchema`, which drops every computed column, stored ones included. When the crud writer applies a replicated delete for a row the destination does not have, the table handler passes that row to `tombstoneUpdater.updateTombstone`. The tombstone updater's row.Deleter is built from `writeableColunms`, which keeps stored computed columns, and indexes the row by position. On a table with a stored computed column, every later column's datum is shifted. For example, on `(k INT PRIMARY KEY, c INT AS (k+1) STORED, v INT, INDEX (v))` the Deleter reads `v` at ordinal 2 of a 2-element row, and secondary-index encoding panics with index out of range. A stored computed column ahead of a primary-key column shifts the primary-key datum in the same way.
hiredis_read_internal stores the address of its stack-local reader_state in connection->context->reader->privdata. Ruby's YJIT can move execution to a different native stack while hiredis retains that pointer, so reply_append later dereferences invalid stack memory. Parsing a Redis response can then read a corrupt task_index pointer and crash the process with SIGSEGV.
The diff gives check the canonical values the checks compare: Channel.run() (portside/channels/base.py) now calls check with `{**record, **self.canonical(record)}` and passes prepare the partner's record as before. Each family base already had a canonical(), which run() logs with every reject: it reads the SKU, quantity, currency and (for storefronts) email from the partner's fields, normalised the way prepare does, through readable() (portside/channels/fields.py), and each family's check ends by reading them strictly, so a channel's own check only runs on a line whose canonical values can be read. The diff changes no hook's signature or return contract and no family base, and the seven channel checks that read one of those fields under another name or normalised it themselves read the canonical value instead. For an EDI line, EdiChannel.canonical() (portside/channels/edi/base.py), which the diff doesn't touch, sets `"quantity": units(record["quantity"], record["uom"], record.get("pack"))`, the canonical quantity prepare also writes through line_totals() (fields.py): the PO line's quantity as ordered (in cases for a CS line) times the pack size. PinecrestChannel.check (portside/channels/edi/pinecrest.py), which the diff doesn't touch, rejects a line when `parse_quantity(record["quantity"]) > self.MAX_QUANTITY` (150), a cap on what one PO line orders that catches a UPC sent in the quantity field. It now compares units against that cap, so every Pinecrest case line over 150 units (13 cases of 12, 26 cases of 6) is rejected as "more than 150 ordered", and those purchase orders are dropped from the warehouse as partner errors. Nothing in the class is wrong on its own and the repo's Pinecrest test (6 cases of 12) passes either way. The other canonical values hold for every check that reads them: a marketplace quantity (Tessera's cap) is only parsed to an int, the register amounts aren't canonicalised, and the SKU, currency and email checks see the same normalisation prepare applies, which changes their outcome only for the partner formats the PR is for.
The diff gives check the canonical values the checks compare: Channel.run() (portside/channels/base.py) now calls check with `{**record, **self.canonical(record)}` and passes prepare the partner's record as before. Each family base already had a canonical(), which run() logs with every reject: it reads the SKU, quantity, currency and (for storefronts) email from the partner's fields, normalised the way prepare does, through readable() (portside/channels/fields.py), and each family's check ends by reading them strictly, so a channel's own check only runs on a line whose canonical values can be read. The diff changes no hook's signature or return contract and no family base, and the seven channel checks that read one of those fields under another name or normalised it themselves read the canonical value instead. For an EDI line, EdiChannel.canonical() (portside/channels/edi/base.py), which the diff doesn't touch, sets `"quantity": units(record["quantity"], record["uom"], record.get("pack"))`, the canonical quantity prepare also writes through line_totals() (fields.py): the PO line's quantity as ordered (in cases for a CS line) times the pack size. PinecrestChannel.check (portside/channels/edi/pinecrest.py), which the diff doesn't touch, rejects a line when `parse_quantity(record["quantity"]) > self.MAX_QUANTITY` (150), a cap on what one PO line orders that catches a UPC sent in the quantity field. It now compares units against that cap, so every Pinecrest case line over 150 units (13 cases of 12, 26 cases of 6) is rejected as "more than 150 ordered", and those purchase orders are dropped from the warehouse as partner errors. Nothing in the class is wrong on its own and the repo's Pinecrest test (6 cases of 12) passes either way. The other canonical values hold for every check that reads them: a marketplace quantity (Tessera's cap) is only parsed to an int, the register amounts aren't canonicalised, and the SKU, currency and email checks see the same normalisation prepare applies, which changes their outcome only for the partner formats the PR is for. The project's history shows the habit the diff breaks: each earlier change to how run() calls the stages (stripping text fields before them, running them from the `stages` list, keeping one channel instance per process) changed, in the same commit, the channels that depended on the old behaviour (Kestrel's PO-length check for the stripping, Tillwise's per-file state for the shared instance).
The diff changes the contract of Handler.validate (sightline/handlers/base.py): it used to raise RecordRejected to reject a record with its return value ignored, and now returns True to keep a record and False to skip it, with run() doing `if not keep: result.skipped += 1; continue`. It adds `return True` to every handler whose validate fell off the end, and turns the expected-traffic rejects into `return False`. It leaves alone the handlers whose validate already ended with a return: the family bases (`return super().validate(record)`), the 25 handlers that end `return present(record, self.kind, ...)` (sightline/fields.py), which returns True or raises, and RefundHandler (sightline/handlers/billing/refund.py), whose validate ends `return note_missing(record, self.kind, "reason")`. note_missing() logs the optional fields a record lacks and returns their names, so for a refund that has a reason it returns an empty list. That was harmless while validate's return value was ignored; now run() reads the empty list as "skip", and every refund that carries a reason (all of them, in practice) never becomes a row: net revenue on the warehouse side silently stops subtracting refunds, with nothing rejected and no error. A refund without a reason is kept. The other handlers that call note_missing() call it as a statement and now return True after it. The handlers are found through the registry that Handler.__init_subclass__ fills. The money family base's @audited wrapper returns the hook's result for reversals and other records alike, and overrides of validate carry no return annotation, so neither shows the contract either way.
The diff changes how handlers are built and called: ingestEvents (ingest.ts) used to call createHandler, which built a new handler for every event, and now calls handlerFor (registry.ts), which builds one handler per event type and HandlerContext on first use and hands every later event of that type to the same instance; it updates the lifetime in the Handler doc comment and docs/handlers.md. Handler.run() already started every event with an empty postings list and a new copy of the event, and no hook's signature or contract changes. PayoutPaidHandler (payout-paid.handler.ts), which the diff doesn't touch, charges the flat payout fee through `this.ctx.fees.payout(this).charge(line.account, line.currency)`. The fee schedule (FeeSchedule in fees.ts), also untouched, keeps one PayoutFees per owner in a WeakMap, so the PayoutFees payout.paid asks for lives exactly as long as the handler. PayoutFees (payout-fees.ts) remembers the accounts it has charged in a Set and returns the flat fee only the first time it sees an account, which implemented the pricing rule "once per seller in a payout" (FeeTable's payoutFlat in fees.ts, and the payout test) while each payout got a new handler and so a new owner. With one handler for every payout.paid event, a seller is charged on their first payout after the process starts and never again: every later payout posts no payout fee, with no error or reject, and the platform's payout fee revenue and the sellers' balances are off by the fee on every repeat payout. Nothing in the class is wrong on its own, and the repo's payout tests pass (each ingests a single payout). Nothing else a shared handler holds changes behaviour: InstantPayoutHandler asks the fee schedule for the event's PayoutFees (`payout(event, speed)`), so its sellers are charged once per payout either way; the 48 rule handlers' WarnOnce and charge.captured's and transfer.created's LineDedupe hold Sets of keys but clear them when they see a new event object, which run() makes for every event; and the rate cache is the context's, which ingest shared before the change too. The handlers are reached only through the HANDLERS table in registry.ts.
The diff changes what Handler.transform's return value means (handler.ts): it used to be "adjust the default row in place, or return a replacement", with run() posting `this.transform(event, row) ?? row`, and now returning nothing drops the event, with run() doing `if (!row) { result.skipped += 1; continue; }`. It adds `return row` to every handler whose transform adjusted the row in place and returned nothing, and makes charge.succeeded and invoice.paid drop zero amounts. It leaves alone the transforms that already end with a return: the family bases, the 21 payout and fee handlers that end `return withMemo(row, ...)` (annotations.ts), which sets the memo and returns the row, and DisputeCreatedHandler (dispute-created.handler.ts), whose transform calls `super.transform(event, row)` and ends `return noteMissing(event, "reason")`. noteMissing() logs the optional fields the event lacks and returns nothing (`: void`), which TypeScript accepts as a return from a transform typed `LedgerRow | void`. That was harmless while run() fell back to the adjusted row; now run() reads the undefined as "drop", and every charge.dispute.created event is counted as skipped: the amount the provider holds back never reaches the ledger, and the held-funds account and the reconciliation against the provider balance are silently off by every open dispute, with nothing rejected. The other handlers that call noteMissing() call it as a statement and now return the row after it. The HeldFunds mixin's @audited transform returns the hook's result for held funds and other rows alike. The handlers are reached only through registry.ts, which the diff doesn't touch. The project's history shows the habit the diff breaks: each earlier change to a hook's contract in handler.ts (validate throwing InvalidEvent instead of returning a reason, adjust(row, event) renamed transform(event, row)) changed every class and mixin defining that hook in the same commit, and the rename changed audit.ts with them.
With CDP_EMAIL_QUEUE_ROUTING on, a workflow's email step now routes the invocation to the new `email` cyclotron queue, the hog_function action copies that queue onto the flow invocation, and the email worker (a hogflow worker on queue `email`) sends the email and keeps running the flow. A `wait_until_condition` step after it therefore parks the job with queue_name='email', which job-queue-postgres-v2 now persists. The hogflow subscription matcher, unchanged by this diff, wakes parked waits through findParkedJobs, which only looks up `queue_name = 'hogflow'`. It never finds the wait, so a matching event does not advance the workflow and it resumes only on the wait's timeout branch.