# Changes by Version Release Notes. ## 0.12.0 ### Features - Push the `LIMIT` and `OFFSET` of an index-mode measure query ordered by time down to the index, and answer it from the indexed `_timestamp` trie instead of reading every document. The native index walks the trie from the coarsest level, takes the buckets that rank inside the limit whole, refines only the bucket that holds the last row, and decodes the few documents that remain, so the cost depends on the limit, not on the number of documents (a 1M-endpoint query with limit 100 drops from seconds to milliseconds). A series that a newer segment already returns is dropped with a lookup of the candidate identifiers in the newer segments (it is no longer collected into a set of every series), and segments entirely beyond the limit-th row are skipped. A criteria is applied to growing chunks of the ranked candidates. Group-by, aggregation, top-N, several groups, an index order, an unbounded limit and a query without a time range keep the full search. - Add a multi-level sort index for numeric tags and use it to answer a limited `ORDER BY ` without reading every document. A scalar int (and timestamp) index-rule tag that is sort-marked (`no_sort` false) is written with 16 prefix-coded precision levels in a companion field (`#t`); a descent over those levels finds the first rows and decodes only the few documents that remain. One native primitive (`TopFieldHits`) serves the stream sort cursor (first page), an index-mode measure ordered by an index rule with a limit, and a normal-mode measure: for a normal-mode measure the index now returns only the first K series under the entity prefix, and the query grows K in rounds until the scanned series hold enough in-range points, so the result is identical to the full ordering. Segments written without the ladder (older data, merges of old and new data, array tags) keep the previous ranking with identical results. The ladder adds about 100 bytes per document for each such field. - Add a Canopy Monitor page for standalone nodes: CPU, memory, disk by path, write rate, query rate with average latency, errors, and storage per group, scraped from the node's `/metrics` through `GET /monitor/snapshot`. Monitoring data, including the raw `/monitoring/*` proxy, is admin only unless `CANOPY_MONITOR_ROLES` opens it to other roles. - Add Canopy sampling pipeline management with Form/YAML editing, independent MERGE, FINALIZE and stage rules, and session-expiry recovery. - [Breaking Change] Trace sampling requires explicit MERGE/FINALIZE event selection; empty events no longer default to MERGE. Add `PIPELINE_EVENT_MERGE` to existing configurations that relied on the implicit default before upgrading. Stage-only pipelines remain supported. - Bound measure QL membership setup, skip proven-empty input, and reuse decoded buffers for eligible order-independent count scans. - Add indexed measure QL LIKE and ILIKE filters with ESCAPE, using whole-value string indexes and bounded native wildcard execution. - Compose scalar expressions inside and around measure QL aggregates, including computed aggregate inputs, HAVING and ordered results. - Add bounded exact decimal SUM through DECIMAL_FROM_SCALED, with exact comparisons and fixed-scale string results. - Add measure QL SELECT DISTINCT, computed and ordinal grouping, selectable time buckets, multi-key ordering with bounded top-k pagination, and exact count-distinct composition. - Add typed measure QL expressions, masked CASE/COALESCE, raw field WHERE, grouped HAVING and compatible CONTAINS membership over shared columnar batches. - Add SQL-correct measure QL grouping and multiple aggregates, with shared calls, weighted AVG, bounded local state and eligible native aggregate split/merge. - Sample traces with source-stage native plugins before lifecycle migration, with durable decisions, checkpointed replay, and crash recovery. - Add typed raw measure QL with WHERE time, aliases and bounded compiled-plan reuse, executed over shared columnar native batches. - Add a native ICE v3 encoder that writes committed index generations compatible with existing readers. - Cut the Property database's index writer over to the native segment plugin, selected by both the `property` and `schema-server` roles. `banyand/property/db.OpenDB` now acquires its exclusive `/lock` before scanning shard directories or opening any writer, and releases it if a later startup step fails. A rollback (flipping the selection back and restarting) reopens the same on-disk shards with the retained legacy writer unchanged. - Complete the Property native role cutover for writes, immutable/NRT publication, repair, filtering, ordering, projection, and persistence. Native is the default for the `property` and `schema-server` roles; the legacy writer remains an explicit rollback path. Native ICE segments reserve `_id` as field ID zero and sort all other field names lexically for mixed-version merge compatibility. See the [Property native cutover verification](docs/design/archive/0.12.0/native-inverted-index/verification/property-native-cutover/README.md) report. - Serve the Stream element index, the dump index resolver, and `bydbctl analyze` from the native index: exact, existence, range, NOT, MATCH (keyword, simple, standard, and URL analyzers), sort, snapshot, and external-segment receive. - [Breaking Change] Property no longer indexes tags named `source`. Schema properties carry their full JSON spec in that tag; the value is still stored, returned, and sortable, but a Property query filtering on a tag named `source` no longer matches. - Route native index file operations through `pkg/fs`, which gains page-cache advice (`AdvisePageCache`, `SetCached`) and error-returning `MkdirAll`, `ReadDirLimit`, `Lstat`, and `SyncDir`. - [Breaking Change] Cut the per-segment series index (Measure, Stream, and Trace `seg-*/sidx`) over to the native index engine and remove the legacy index engine-backed series store: `pkg/index/inverted`'s series-only query builders, matchers, and tests are gone, and `banyand/internal/storage` no longer imports `pkg/index/inverted` or the retired third-party search engine at all. There is no engine flag and no switch between engines; upgrades are whole-cluster (stop every node, start the new binary on the same data directories) and rolling/mixed-version upgrades are not supported. Rollback is a file property, not a code path: `sidx` directories remain ICE v3 segments and snapshot v3 manifests the previous release already reads, and the new writer keeps writing `_id` doc values so a rolled-back node still reads document identity. Also removes Property's now-dead legacy writer switch (`IndexConfig.NativeWriter`, `SwitchIndexWriter`, `shard.store`) — native was already the only reachable production path — and moves the Property dump tool and the schema-property reader's document walk off `pkg/index/inverted` onto the native read-only API. The Stream element index (`idx/`) now also writes `_id` doc values, fixing a previous-release rollback reading its document IDs as zero. Every remaining confirmed-dead legacy scaffolding in `pkg/index/inverted` (the abandoned native-segment-plugin bridge, the superseded repair-page reader, and the read-only duplicates `pkg/index/native` already owns) is deleted outright rather than left unreferenced. Fixes a cold-first-lookup latency regression the native series index had carried since its own cutover (the per-segment identifier filter was built lazily, on first query, instead of once at segment-construction time); every `§13` performance target (write throughput, exact/prefix/wildcard lookup, index-order search, external receive) is now met, several by a wide margin. See the [NIDX-03 series index cutover verification](docs/design/archive/0.12.0/native-inverted-index/verification/nidx-03-series-cutover/README.md) report (rollback proof re-run against v0.11.1, the actual last published release, with a real crash-cut and a real gRPC round trip through a built-from-source previous-release binary); `banyand/stream/migration_element_index.go` (the Stream element-index migration tool, NIDX-04) remains the only production user of `pkg/index/inverted`, which is otherwise unused. - (NIDX-04) Cut the Stream element-index migration tool over to the native index engine: `banyand/stream/migration_element_index.go`'s target-store writer and `banyand/stream/migration_verify.go`'s doc-count reader (renamed `CountElementIndexDocs`) no longer use `pkg/index/inverted`, so `banyand/stream`'s production (non-test) source no longer imports `pkg/index/inverted` or the retired third-party search engine at all (enforced by an updated dependency-guard test). The migration writer opens one native store per target shard behind its own throwaway root lease (matching the series-index union builder's and Measure's index-mode copy tool's established pattern), writes synchronously so a batch is durable before the call returns, and durably persists on close. The native reader opens both a native-rebuilt and a byte-copied previous-release (legacy-format) `idx/` directory transparently, so the migration's existing byte-copy fast path is unaffected. - (NIDX-05) Remove the retired third-party inverted-index library from the repository entirely. `pkg/index/inverted` and `pkg/index/analyzer` are deleted; their remaining native-engine test coverage (checked-in historical fixtures and native-only read-path tests) moved to `pkg/index/native`, and the fixture corpora moved to `pkg/index/testdata` / `pkg/index/native/testdata`. The two series/element tag-filter range operators (`banyand/internal/sidx`, `banyand/stream`) now use `pkg/encoding`'s own sortable float/int64 encoding instead of the library's `numeric` package — byte-identical output, pinned by literal test vectors. `go.mod`/`go.sum` no longer reference the library, its ICE segment codec dependency, or any indirect dependency only they pulled in; `dist/LICENSE` and `dist/licenses/` are regenerated to match. The obsolete index-local lock filename is also removed, along with every constant, filter, fixture, and test that named or depended on it — writer exclusion was already owned by BanyanDB's own database lock, so this changes no observable behavior; a stray leftover lock file in an upgraded data directory is harmless and ignored by the native engine's directory scans. Compatibility evidence for v0.11.1-written directories survives only as checked-in, immutable fixture bytes with neutral provenance (a producing revision or a content hash); no test, tool, build script, or generated artifact depends on the retired library any more. - Bound the native index's memory: merges stream to disk instead of materializing the merged segment, so their memory no longer grows with segment size or fan-in; persisted segments are no longer held in the heap but served from their files through `pkg/fs` (one descriptor per segment, term dictionaries read in place, a per-field bloom filter of at most 2 MiB kept for existence checks); and staged merge outputs and external segments are published by rename, so no staged name survives a restart. The on-disk format is unchanged and v0.11.1 directories open as before. In the 2.4M-series write-growth benchmark, peak RSS falls from about 1.7 GiB to about 450 MiB and the live heap after reopen from about 120 MiB to 6 MiB. - Store BanyanDB's own logs in BanyanDB, behind `--logging-native-enabled` (off by default). Events land in the `_monitoring_log` stream group and are queryable through the ordinary stream API. Normal logging stays enabled and is never degraded by it; the two destinations have independent levels, so native can retain `info` and `warn` while stderr stays at `error`. Like native metrics, a standalone or data node writes its own logs through its local write path to shard 0 of the single-shard group. A liaison, which has no storage, writes its logs as a stream write, through the liaison write queue that syncs them to the data nodes. `backup`, `lifecycle`, the FODC agent and the FODC proxy store theirs too: each writes to one node, the data node beside it or a liaison's public write API, and that node keeps the schema with `--logging-native-receiver-enabled`; the FODC binaries connect with `--logging-native-addr`, `-tls`, `-ca-cert`, `-username` and `-password`, and the FODC agent takes its route from `--logging-native-route`. Six flags configure collection (`--logging-native-enabled`, `-level`, `-modules`, `-levels`, `-exclude-modules`, `-ttl-days`); buffering, writing and memory are internal, and the sink drops and counts while the memory protector reports high pressure. The native log service's own logging and the storage of `_monitoring_log` are never collected, whatever `--logging-native-exclude-modules` says, and an event logged without a level is stored as `none`. Existing `GetLogger` callers need no change. - [Breaking Change] Bump the segment file format version to 1.6.0 (1.4.0 and 1.5.0 remain readable). Trace `blockMetadata` gained a timestamp-bounds marker and min/max timestamps in 0.11 without a version bump, so trace data written by 0.10 cannot be read by 0.11 or later: every trace query touching such a part fails. Delete trace data written by 0.10 before upgrading. See [Upgrading to 0.12](docs/operation/upgrade.md#trace-data-written-by-010-is-unreadable-breaking). - Add logging related flags to the FODC proxy and agent. Every BanyanDB binary now shares the same logging flags and the matching `BYDB_LOGGING_*` environment variables. - [Breaking Change] Remove the row-based query execution path from the Stream, Measure and Trace query engines. Measure TopN pre-aggregation is unchanged and still executes row-based. The `--stream-vectorized-enabled`, `--trace-vectorized-enabled` and `--measure-vectorized-enabled` flags are removed; a node started with one of them fails at startup with an unknown-flag error. A query shape the vectorized engine cannot plan now returns an error instead of falling through to row execution. See [Upgrading to 0.12](docs/operation/upgrade.md#upgrading-to-012). - Push the criteria tag filter ahead of the vectorized stream merge, so a filtered index-order query bounds its merge at limit+offset. For such a query, where several rows share an ElementID, the criteria is now evaluated first and the element is represented by its first matching row in the requested sort order. - Keep Stream filtering and client projection on the columnar batches until output, so a filtered distributed Stream query emits a native columnar frame instead of per-element protobuf. A filtered index-order query no longer re-evaluates the criteria per element: the pre-merge columnar filter already decided it, and only the hidden-tag removal remains. The egress now drops criteria-only tags as whole columns, before it builds either response. So the protobuf response no longer builds an Element only to filter it away. The internal order key is not a tag column, so it stays. Traced queries and standalone queries keep the protobuf response. - `measure.v1.QueryRequest.Aggregation` can now target a tag (`tag_name` + `tag_family`) instead of a field: `SUM`/`MIN`/`MAX`/`MEAN` over an `INT` tag, and `COUNT` over any scalar tag, in both standalone and distributed queries. Wire-additive only — existing clients that only ever set `field_name` are unaffected. See the [tag aggregation and time bucketing design](docs/design/0.12.0/tag-aggregation/README.md). - `measure.v1.QueryRequest.GroupBy.time_bucket` groups a measure query by tumbling time windows, alone or combined with a tag `GroupBy`, in both standalone and distributed queries. The bucket width comes from the request or falls back to the measure's own `interval`. The part-scan path streams bucket-by-bucket so live memory never exceeds one bucket's groups; index-mode measures (no ascending-timestamp guarantee) use a bounded non-streaming fallback instead. A mixed-version cluster where an older data node ignores `time_bucket` is rejected with a clear error rather than silently collapsing the series to one row. - Fold each maximal `(series, bucket)` span of a measure `GroupBy`/`Aggregation` once instead of per row whenever every group key — and, for `COUNT`/`COUNT_DISTINCT`, the aggregation target — resolves from the series index (an entity tag, or a tag carrying an `IndexRule`) rather than the part's tag columns: `COUNT_DISTINCT` collapses to one set insert per span and `COUNT` to one bulk increment, while `SUM`/`MIN`/`MAX`/`MEAN` and any non-index-resolved target still fold per row but skip the now-redundant per-row key computation and group lookup (the tag-aggregation design's §7.7 "run-folding" stage). Pure performance — results, the wire format, and the API are unchanged. - Improve Canopy text readability: raise the faint and dim text contrast, lift every font size to at least 12px, use heavier sub-navigation weights, stop forcing antialiased font smoothing, and load IBM Plex Mono 600 and Sans 700. The query builder rail is wider by default (400px) to fit the larger text. - `databasev1.Node` now reports its supported file format versions and IANA time zone name. - Resolve BydbQL measure, stream and trace schemas from the liaison's watch-fed schema cache instead of the schema registry, which queried every metadata node on each request. A registry read is now made only when the cache has not yet seen a newly created resource. A BydbQL query no longer pays a metadata round trip per group (about 0.4–0.6 ms each on loopback), and no longer triggers the registry's read-repair of lagging metadata nodes. - Decode null-free int64 and float64 measure columns straight into typed slices on the vectorized query path, instead of one heap-allocated byte slice per value that the batch then converted back. Filling an 8,192-row numeric column drops from about 0.5 ms and 8,196 allocations to 40–86 µs and 2 allocations. Merge, flush, TopN and columns containing nulls keep the byte form. - Reference-count measure block cursors so batch string, bytes and string-array tag cells borrow the decoded block memory instead of copying each value; a cursor returns to its pool only when the last batch borrowing from it is released. Operators that keep values past their input batch (group-by, aggregation, TopN) and the response edge copy what they retain. Decoding an 8,192-row string column drops from 8,193 allocations to 1, and 33–58% in time. `BYDB_POISON_RELEASED_CURSOR=1` overwrites released cursor memory to expose use-after-release in tests. - Emit every projected measure tag and field with a known schema type as a native typed column instead of a protobuf passthrough column, and build each response value in one allocation. Plain scans now decode without per-value wrappers and pay them only for rows that reach the response: on real stored blocks a full scan is 16% faster with 38% fewer allocations, limited and TopN scans 23–65% faster, and a distributed full-scan frame 49% faster with 99.7% fewer allocations. The wire format is unchanged. - Stop allocating per input row in measure aggregation and TopN: group and replica-dedup keys are looked up from a reused buffer and copied only when a new group is inserted, and a TopN row that displaces the heap root reuses the root's storage. On real stored blocks, group-by + aggregation queries drop from about 103k to 2.8k allocations and TopN from 472k to 32k (15% faster). - Stream vectorized measure scans one series window at a time instead of decoding every matching block before the first row. A series whose blocks do not overlap in time is handed to the pipeline block by block without copying, numeric and timestamp columns included, at block size (up to 8,192 rows); descending order uses a reversed selection instead of a reversed copy, and windows under 256 rows are coalesced. Overlapping segments still merge. On real stored blocks the eight gate workloads are 53% faster (geomean). New counters report how many windows and segments take the fast and the overlap path. - Replace the eager decode-and-merge of time-ordered vectorized measure scans (the default when a query has no ORDER BY) with a time-ordered merge: a block is decoded only when the merge reaches its first timestamp and released as soon as its rows are consumed, keys are merged before values, and each column is gathered once per page with strings borrowed zero-copy. Output order is unchanged; peak decoded blocks drop from every matching block to about one per series. Multi-series queries over a shared time range are 54–57% faster on real stored blocks. - Decode vectorized measure scan blocks on a node-wide pool sized to GOMAXPROCS instead of one goroutine per block, prefetching ahead in consumption order with a depth that grows while memory reservations succeed. Each block reserves its decoded size before decoding and releases it when the last batch borrowing from it is released, so a scan's memory is accounted by what it holds rather than checked once against its whole result: prefetch waits under memory pressure, the protector is consulted only when a query is admitted, and a query fails with the existing `block scan quota exceeded` error only when the block it needs next would put it over its own quota. - Store a series' entity tags once per batch as a constant column in single-series vectorized measure batches, and aggregate by runs: when every group key is constant over a run of rows (constant columns, entity tags of a known series, or a time bucket over time-ordered rows), the group is looked up once per run and the run is folded with typed loops in the same order as before. Group-by + aggregation over real stored blocks is 57–68% faster; results are bit-identical. - [Breaking Change] Add measure frame version 4, a columnar data-node-to-liaison wire format that replaces the row-oriented measure frame (version 3): each column's validity, offsets and values are sent as contiguous 8-byte-padded buffers, and the liaison builds columns by slicing the received message instead of allocating per cell. Data nodes always send version 4 and a liaison accepts only version 4 for measure frames, rejecting any other version with an error; there is no version negotiation and no fallback. BanyanDB 0.12 does not support rolling or mixed-version upgrades, so upgrade the whole cluster at once (stop every node, start the new binary); see [Upgrading to 0.12](docs/operation/upgrade.md#upgrading-to-012). Decoding a 4-column 8,192-row batch drops from 16,416 allocations and 0.85 ms to 38 and 0.14 ms for 6% larger frames; a distributed full scan is 38% faster. - Add data export and import between clusters via `bydbctl data export` and `bydbctl data import`, using CSV artifacts. `model.v1.Status` gains `STATUS_RATE_LIMITED`, answered by a data node whose import rate limit cannot admit a batch in time. - Add the data export protocol (`transfer.v1.ExportService`) and `bydbctl data export` with dry-run and CSV export, showing the progress and time of every file, unit and node. - Add the data export dry-run protocol (`transfer.v1.ExportService`) and `bydbctl data export --dry-run`. - Support receiving Property shards through file chunk sync (`TopicPropertyPartSync`): data nodes stage the received native index files and repair each document into the target shard. - Support the native format in `bydbctl data export` and `bydbctl data import`: data nodes pack the parts and indexes of the session snapshot into `.bnc` containers, and the import relays them through the new `transfer.v1.ImportService/ImportParts` RPC to every target data node over the chunked sync protocol, refusing a target of another topology, time zone, segment format version or index rule id; index rules the import creates keep the artifact's ids. `--part-rate-limit` and `--part-chunk-size` tune the part push. - Merge the local multi-group Stream query as columnar batches. The per-group batches go through one `SortedMerge` → `Distinct` → `Limit` pipeline and Elements are built once from its output, instead of one Element list per group merged row by row. A schema-evolved group keeps its own tags, and an ElementID returned by several groups is now returned once (first group wins). `logical_stream.MergeGroupElements` is removed. - Defer building Elements from distributed Stream frames until the liaison has merged, deduplicated, and paginated the results. Frame and protobuf replies share the existing multiway merge. Index-ordered frames use their OrderKey column and are rejected when that column is missing. - Stream distributed trace query results from data nodes to the liaison in chunks over a server-streaming transport, so a data node no longer materialises its whole result into one message. There is no longer a per-node 32 MiB response limit, cancelling a query now reaches the data nodes instead of letting them scan until a fixed deadline, and the fixed 5 s per-node deadline becomes a 15 s idle deadline that every chunk and data-node heartbeat resets; the liaison states the idle timeout in the request and the data node heartbeats at a fifth of it. A data node that fails during a trace query now fails the query instead of sometimes returning partial results silently. The unary `Query` response is unchanged. - Stream distributed stream query results from data nodes to the liaison in chunks over a server-streaming transport, so a data node no longer materialises its whole result into one message. There is no longer a per-node 32 MiB response limit, cancelling a query now reaches the data nodes instead of letting them scan until a fixed deadline, and the fixed 5 s per-node deadline becomes a 15 s idle deadline that every chunk and data-node heartbeat resets; the liaison states the idle timeout in the request and the data node heartbeats at a fifth of it. A data node that fails during a stream query now fails the query instead of sometimes returning partial results silently. The liaison asks for chunks of at most 4096 elements and 4 MiB. The unary `Query` response is unchanged. - Acknowledge trace `Write` streams per sealed batch while the stream stays open. The liaison groups each stream's rows per data node and seals a batch at 8 MiB or 200 ms after its first row, then sends the existing `WriteResponse` for every message of a batch as soon as its data node has applied it, instead of only after the client half-closes; liaison memory no longer grows with the length of the stream. `WriteResponse` gains `status_code` (the typed form of `status`) and `retry_after_ms` (a request to pause sending), and `model.v1.Status` gains `STATUS_SERVER_BUSY`, reported by a data node under memory pressure. The window of sealed, unacknowledged batches per node adapts (4 to begin with, growing to 16 on clean acknowledgements, halving when a node refuses a batch, and not growing while the liaison is under memory pressure); when it is full the liaison stops reading from the client, which blocks it through HTTP/2 flow control. A batch a data node refuses with `STATUS_DISK_FULL` or `STATUS_SERVER_BUSY` before applying it is retried by the liaison with backoff while acknowledgements carry `retry_after_ms`; if that lasts past the stream's deadline (30 s when the client set none) its messages are answered with `STATUS_SERVER_BUSY` and the stream ends with `RESOURCE_EXHAUSTED`. A batch whose outcome is unknown is reported, never replayed by the liaison. Clients that send everything and read afterwards keep working: responses leave through a queue that never blocks the receive loop. The request message is unchanged. - Acknowledge stream `Write` streams per sealed batch while the stream stays open, as trace `Write` streams are. The liaison groups each stream's rows per data node, seals a batch at 8 MiB or 200 ms after its first row, and sends the existing `WriteResponse` for every message of a batch (keyed by its `message_id`) as soon as its data node has applied it, instead of only after the client half-closes; liaison memory no longer grows with the length of the stream. `WriteResponse` gains `status_code` and `retry_after_ms`, a data node under memory pressure answers `STATUS_SERVER_BUSY`, and the liaison retries such a batch (and a `STATUS_DISK_FULL` one) with backoff, bounded by the in-flight window and by the stream's deadline (30 s when the client set none), ending the stream with `RESOURCE_EXHAUSTED` when the pressure outlasts it. The batching, window and pressure behaviour is shared with trace. Clients that send everything and read afterwards keep working. The request message is unchanged. - Stream distributed measure query results from data nodes to the liaison in chunks over a server-streaming transport, so a data node no longer materialises its whole result into one message. A data node sends one frame per batch of its pipeline (at most 4096 rows and 4 MiB), a time-bucketed group-by on a part-scan measure sends its partials bucket by bucket in time order, and every other aggregation sends its partial when the scan ends. The liaison merges the node streams lazily, keeping its two dedup rules (the highest version per series ID and timestamp within a sort group, and in index mode a series seen in an earlier sort group is suppressed, its seen-set charged to the query lease), reduces a time-bucketed group-by once every node has passed a bucket, and charges the state of the buckets still open to the query lease. There is no longer a per-node 32 MiB response limit, cancelling a query now reaches the data nodes instead of letting them scan until a fixed deadline, the fixed 15 s per-node deadline becomes a 15 s idle deadline that every chunk and data-node heartbeat resets, and a data node that fails during a measure query fails the query. A data node now admits a measure query against its query pool, returns the memory a streamed scan releases to the query lease, and reports a query over its allowance as `STATUS_RESOURCE_EXHAUSTED`. The `--dst-broadcast-timeout` flag is removed because nothing uses it any more. The unary `Query` response is unchanged. - Acknowledge measure `Write` streams per sealed batch while the stream stays open, as trace and stream `Write` streams are. The liaison groups each stream's rows per data node, seals a batch at 8 MiB or 200 ms after its first row, and sends the existing `WriteResponse` for every message of a batch (keyed by its `message_id`) as soon as its data node has applied it, instead of only after the client half-closes. `WriteResponse` gains `status_code` and `retry_after_ms`, a data node under memory pressure answers `STATUS_SERVER_BUSY`, and the liaison retries such a batch (and a `STATUS_DISK_FULL` one) with backoff, bounded by the stream's deadline (30 s when the client set none). A retried data point is an upsert of the same version, so a replay is safe. The request message is unchanged. - Canopy local authentication: a validated `auth` config (`CANOPY_AUTH_CONFIG`, `CANOPY_AUTH_*` overrides, `CANOPY_USERS` kept as an alias) with argon2id passwords (pure WASM, standard PHC strings; bcrypt still verifies with a startup warning), no default admin, and Horizon role names mapped to `admin`/`readonly`. Sessions are now server-side with sliding expiry (`canopy_sid` cookie) instead of an encrypted cookie, so logout revokes and role or user changes apply without re-login; existing sessions are signed out once on upgrade. API tokens (`auth.tokensFile`, `Authorization: Bearer hzn__`) authenticate as a named user whose role is re-resolved from the live config. - Canopy SSO: `auth.backend: sso` signs users in through OIDC (issuer discovery) and OAuth2 providers with authorization code, PKCE, `state` and `nonce`, verifying ID tokens (RS256/ES256) against the provider's JWKS. The client secret comes from the environment or a file, never the config file. `auth.sso.roles` (`defaultRoles`, `roleByEmail`, `roleByDomain`) maps logins to `admin`/`readonly`, and a login with no matching role is refused. Access tokens issued by an SSO provider are accepted as bearer credentials ahead of API tokens and cookies, and role mapping and break-glass edits apply to live sessions within seconds. `auth.breakGlass` local accounts can sign in through `POST /auth/login` only while every SSO provider is unreachable (WARN log with username and client IP). `GET /api/meta` reports the providers, SSO health and break-glass availability to the login page. Adds `canopy/docs/auth-design.md` and documents every auth key in the Canopy README. ### Bug Fixes - Apply `AGGREGATE BY` of a pre-built TopN query to every value of an entity in the time range, then take the top N, instead of aggregating after keeping one value per entity. COUNT no longer returns 1, and MEAN, SUM and MIN no longer return the best value of each entity. The TopN processor now stores each result row on the shard of its own series (TopN name, direction and group) instead of the source shard of the window's last-ranked tuple, so all the windows of one group in one lifecycle stage live on one shard. Data nodes answer a new internal TopN query with per-shard partial aggregates (sum and count for MEAN), and the liaison counts each shard's answer once, so replicas are not added twice, merges the partials and takes the top N. A query aggregates within one TopN group: a query of one lifecycle stage of one group that pins every group-by tag with its conditions, or whose TopN has no group-by tags, asks every shard for its local top N and is exact; any other query (spanning stages or groups, or reading every group-by value, so that an entity's windows are spread over several shards) asks every shard for its best `counters_number` items, exact as long as no shard holds more items than that in the range and approximate otherwise, like the pre-built TopN itself. The per-group guarantee holds for TopN data written after upgrading. A data node still answers the TopN query of an older liaison as before, while a liaison needs data nodes that serve the internal TopN query, so upgrade the data nodes first. A TopN aggregation without `field_value_sort` now ranks its ascending list in ascending order instead of keeping the largest values in both lists. (apache/skywalking#14217) - Stop the rotation scan from reopening idle-closed segments, and let a write into an existing segment skip the controller's writer lock. The scan reopened every closed segment under the controller's read lock on each tick, undoing the idle reclaimer (a reopen does not refresh the segment's last-access time) and stalling writes and queries for the length of the reopen, about 27 s for a large stream segment, every 10 minutes. - Reduce a standalone multi-group Measure aggregation across the groups instead of returning one row per group. MEAN, Top, LIMIT and time-bucketed results now match the distributed cluster: each group runs in partial mode and the partials are reduced with the liaison's reducer before Top, offset and limit are applied once. Like the cluster, a standalone node now rejects such an aggregation when its groups declare the same projected tag with different types. - Keep every tag and field when a merge combines blocks whose layouts differ, for example after a schema change. A new tag, tag family or field could reallocate the block's columns and drop the values appended to a column after it, leaving it shorter than the block; merging that block again panicked and stopped the shard's merge loop for good, so parts piled up and queries slowed down until they exhausted the query memory pool. Affects measure, stream and trace. - Apply the limit of a trace query with a tag filter at the index again, so it no longer reads every matching trace and exhausts the query memory pool (a regression from #1444). A trace query that goes over its memory budget now reports RESOURCE_EXHAUSTED instead of an internal error. - Crash the process when a long-lived background loop panics, after the panic is logged and its diagnostics are written: the storage loops (introducer, flusher, merger and syncer of measure, stream and trace tables, and the trace merge lanes), segment rotation and retention, the cache cleaner, native index persistence and compaction, scheduled tasks, TopN processing, trace handoff replay, the buffered queue consumer, schema watching, node membership, the memory protector, property gossip, the internal gRPC and health servers, and the TLS and connection watchers. run.Go used to recover such a panic and keep the node running with the loop gone, so its work stopped silently; a measure merge loop that panicked this way left its shard unmerged until the parts piled up. Request-scoped goroutines still recover and fail only their request. - Stop a measure, stream or trace table flush when the table closes, and remove the parts it already wrote. A flush abandoned at close used to leave its part directories on disk while the same data stayed in memory, so the loop could write the same part IDs again and fail with "file exists"; a long flush also held up shutdown though its result was discarded. - End a schema watch session's receiver goroutine with its session, so a reconnect no longer leaks a goroutine blocked on sending an update nobody reads. - Accept the `Bearer` authorization scheme case-insensitively in the MCP HTTP server, so `Authorization: bearer ` is no longer rejected with 401. - Make the MCP server load `.env` before reading configuration and validate settings strictly: numeric settings (`MCP_PORT`, `MCP_MAX_BODY_BYTES`, `MCP_RATE_LIMIT_*`) must be plain positive integers and `TRANSPORT` only accepts `stdio`/`http` (case-insensitive); invalid values now fail at startup with a clear error instead of being silently altered. Fixes apache/skywalking#14194. - Skip a stream group whose schema is unknown on a distributed data node instead of failing the whole query, so a stream schema that has not propagated to that node yet no longer discards the results the rest of the cluster serves. A standalone node and the liaison still report an unknown stream schema as an error. - Fix DictionaryFilter.ContainsAll mutating cached filter arrays during UnmarshalVarArray causing false-negative block skips, and harden trace query and sidx element decoding against in-place unescaping. - Guard shared empty posting list against in-place mutations in query filters without adding allocations to the empty-search path. - Fix unintroduced merged and flushed parts leaking open file descriptors and orphaned directories on shutdown in measure and stream. - Stop rejecting stream, trace and property queries whose limit + offset exceeds 1792 when no memory limit is configured. Admission estimated 4 KiB per requested row before reading data, so OAP's default LIMIT 10000 failed with RESOURCE_EXHAUSTED even on tiny datasets; memory is still bounded by the 100,000-row window ceiling, the preallocation caps and the charges for data actually read. - Apply trace query limits after span-ID and other residual filters so older matching traces remain queryable. - Keep native index compaction progressing when persistence replaces unchanged in-memory segments with file-backed readers. - Fix a tag-filtered timestamp-order Stream query that found a match only within the first `limit` elements of its series: the criteria filter now runs ahead of the vectorized merge cap for every order, so the limit fills from the matching elements wherever they sit (apache/skywalking#14215). - Upgrade the Go toolchain to 1.26.10 for the crypto/x509 security fix (GO-2026-6809). - Upgrade the Go toolchain to 1.26.11 for the net/http security fix (GO-2026-6859). - Fix the native index reader rejecting valid segments as corrupt when a term dictionary exceeded 64 MiB (for example, unanalyzed log bodies indexed as single terms), which crash-looped the data node on startup. The reader no longer applies fixed size caps the writer and merger do not honor: dictionaries, stored chunk tables, stored-document counts per segment and posting bitmaps are bounded by the segment's own sections and document count, a stored chunk's decoded length is bounded by its last document's offset plus a 64 MiB per-document limit that `EncodeSegment` now enforces, and the exact term set a small segment retains is bounded by term count and bytes. `PublishSnapshot` now rejects a manifest the reader would refuse (limit raised from 16 MiB to 256 MiB) before writing any file. - Return zero for empty scalar QL `COUNT(DISTINCT)` and apply its pagination after the complete count instead of pruning native shard partials. - Preserve indexed-array measure values, empty-entity selector semantics and retained merge-tail buffers in shared batch execution. - Fix the liaison's distributed measure row merge wrapping borrowed frame strings into protobuf tag and field values without copying them. - Fix a data node panicking with "directory is exist" when a write landed in a segment that retention had just removed but whose directory was still held by a reader; creating a segment over a directory pending deletion now returns `ErrSegmentDeleting`. - Fix the stream block scanner counting each scanned block against the scan quota once per later block in its batch (and carrying the total across batches), which made a scan report `block scan quota exceeded` and wait for far more memory than its blocks need; the quota and the reservation now use the bytes of the current batch only. - Fix data races in measure queries, which wrote the block cache and shard ID into parts shared with concurrent queries; both are now carried alongside each part. - Fix a data node with several measure groups exporting query metrics only for the most recently opened group: opening a group closed every other group's query metrics. Each group now keeps its own. - Fix the vectorized measure batch merge emitting a duplicate row when a same-series, same-timestamp duplicate straddled its 4,096-row page boundary; the row path already returned the deduplicated result. - Fix stream queries silently dropping the later blocks of a series: the block filter's verdict is per-block, but `findBlock` advanced a whole series on skip. - Fix a stream query with a small `limit` failing with `query memory pool exhausted` once it scanned more than the per-query allowance (8 MiB without a cgroup limit): the vectorized scan decoded and charged a whole segment before returning a row, and the sorted merge charged every batch it consumed, and neither charge was ever returned. The scan now decodes one scanner batch of blocks on demand and the query budget gains `Refund`, so the scan refunds a block when its cursor is released and the merge refunds a batch once a prune drops its last retained row. A data node now also reports a query over its memory allowance as `STATUS_RESOURCE_EXHAUSTED`, so clients receive `RESOURCE_EXHAUSTED` instead of a generic internal error. See apache/skywalking#14165. - Fix a data race in Measure TopN where a pooled TopN value reused for a query wrote its tag names into the streaming processor's entity tag name slice. - Fix `Measure` TopN dropping a timeline entry that can never come back: `DedupPriorityQueue.ReplaceLowest` overwrote the lowest item without releasing the replaced one from the dedup caches, so pushing it again was silently skipped, and never registered the replacing one, so a duplicate of it was accepted. - Stop `pkg/index/native`'s compaction-persistence test from flaking on `Test Pkg`: it asserted that garbage collection succeeds the instant a read view closes, without accounting for a background persist still holding an older root. - Stamp `RELEASE_VERSION` into official release binaries so `--version` reports the release instead of `-`. - Pack the source release from `git archive` and reject archives that contain ELF/Mach-O binaries. - Stop declaring unbundled MCP npm dependencies in binary-package root `LICENSE` files (MCP Eyes output stays under `mcp/`). - Keep MCP and Canopy dependency license texts under `mcp/licenses/` and `canopy/licenses/` (checked in). Go binary packages that stage MCP also ship `mcp/LICENSE`, `mcp/licenses/`, and `mcp/package-lock.json` with `mcp/dist`. - Ship Canopy as an independent release archive (`skywalking-banyandb-*-canopy.tgz`) with built SPA/BFF artifacts and Canopy Eyes licenses. - Include the full Apache-2.0 text in Canopy's root `LICENSE` and drop the accidental Linux-only `@rollup/rollup-linux-x64-gnu` hard dependency so `npm ci --omit=dev` works on macOS ARM64. - Reject group / stream / measure / trace (and related) resource names that are not a single path-safe identifier (`[a-zA-Z0-9_]([a-zA-Z0-9._-]*[a-zA-Z0-9])?`), so names cannot escape catalog storage roots. - Bound protobuf `validate.rules` on schema and query identifiers (max length, allowlist pattern, repeated max_items, numeric ceilings) so untrusted inputs cannot escape storage roots or force unbounded allocations. - Honor the configured logging level in native observability metrics instead of retaining the pre-initialization debug logger. - Fix FODC proxy `/metrics` returning partial data or timing out when concurrent scrapes overlap. - Bound Property, Stream, and Trace query allocations with shared memory admission and capacity hints so oversized limit/offset windows cannot force huge result buffers. - Preserve list-all / max-limit queries (`limit=MaxUint32` or OAP `Integer.MAX_VALUE`) with incremental scan admission and result-count accounting, without over-charging Property source payloads against the liaison fallback pool. - Move the trace-pipeline plugin dynamic-lifecycle coverage out of `test/integration/{standalone,distributed}/pipeline` into a new `test/e2e/tracepipeline` gate (`make test-trace-pipeline`, `.github/workflows/test-trace-pipeline-e2e.yml`). The deleted suites forked a `banyand-server` binary through `pkg/test/setup/external.go`, which contradicted the project's "integration tests run in a single Go process" principle and silently skipped in CI because the prepare job did not build the binary. The new gate always builds the .so + CGO server it needs and runs against a real standalone process, so the dynamic Register/Update/Remove/InvalidConfig lifecycle plus the schema-store replay after process restart are now exercised on every PR that touches the trace pipeline. The same coverage is still available at the unit-test level in `banyand/trace/pipeline_watch_test.go` and `banyand/trace/pipeline_chain_filter_test.go`. - Register the memory protector on the liaison role so query admission uses the cgroup-backed pool instead of the 64MiB fallback. - Bound Cluster and Rover e2e BanyanDB memory so cgroup limits enable the query budget under resource-constrained environments. - Enforce trace query time ranges independently of the sort index, skipping row timestamp checks when the query fully covers a part. - Keep system native `memory_state` (with `kind` labels) from being overwritten by the liaison load-shedding gauge so self-observability dashboard queries succeed. - Retry property schema registry initialization indefinitely, logging an error every 10 attempts. - Authorize frames on write streams that were opened before RBAC was hot-enabled, so enabling RBAC mid-stream cannot leave long-lived Measure/Stream/Trace writes unchecked. - Reload auth config when the watched path is a symlink and its target file changes (ConfigMap-style layouts). - Re-fetch file/DNS discovery nodes that are parked in the retry queue while discovery has not Start()-ed yet, so unbounded PreRun schema-registry retries can recover once peers become reachable without restarting liaison. - Keep DNS discovery `ListNode` successful when some SRV addresses refuse connections but at least one node was discovered, so non-meta nodes no longer deadlock in PreRun on their own not-yet-listening gRPC address. - Fix un-interruptible sleep on shutdown during snapshot sync retry and add jittered backoff for stream, measure, and trace. - Report the real shard ID in `CollectDataInfo` shard info for stream, measure, and trace instead of the live table's slice index, so a node that owns only higher-numbered shards is no longer attributed to shard 0 in cross-node shard-load analysis. - Reject a measure or stream whose tag name appears in more than one tag family, or twice within one family, when it is created or updated. The query layer resolves a bare tag name against a flat map keyed by name alone, so such a schema previously registered successfully and then resolved that name differently depending on which query path read it. Already-persisted schemas keep loading unchanged; only the registry's create and update paths enforce the rule. - Fix a silently wrong result from the vectorized measure liaison's aggregation reduce when a single per-node partial exceeds 65,536 rows: past that boundary the consuming row index wrapped, folding early rows into a group a second time and never visiting the rest, with no error. It is reachable today on `Top`-bearing queries, whose per-node limit is unbounded. The reduce now consumes an oversized partial in bounded chunks, and `BatchSize` is capped at `MaxUint16` so it cannot reopen the same wrap from the output side. The liaison's raw `Top` and raw `GroupBy` passes are chunked the same way; their callers already page at `BatchSize`, so that part is hardening rather than a live fix. - Reject a `--trace-vectorized-batch-size` above 65,536 at startup instead of accepting it. The trace query path indexes a batch's active rows through a `uint16` selection, so a batch size above that bound silently wrapped -- reading early rows a second time and never reading the rest. The stream path already enforced this bound; measure now does too. A node configured above the bound will fail to start rather than return wrong results, and must lower the flag. - Fix FODC proxy OOM kills on `/metrics`: stream the Prometheus text to the response, stop copying label maps, share one agent collection between concurrent scrapes, and install the same panic diagnostics as the agent. - Stop the scheduled backup/lifecycle/retention scheduler from logging a false `action timed out` error for an action that runs longer than 5 minutes but ultimately succeeds. Crossing the internal 5-minute soft deadline now logs a lower-severity "still running" message and keeps waiting for the action's real outcome instead of abandoning it mid-flight; the eventual result is logged and the scheduler only starts the next scheduled run once the current one truly finishes. - Fix backup reporting success when an earlier catalog upload fails. - Return a trace's complete span set when its spans straddle a storage segment boundary (segments are per-day in local time, and each span lands in the segment matching its own timestamp) and the query's time range covers only one side of that boundary. After resolving the qualifying trace IDs from the segments the query range overlaps, fetching those traces' spans now also reopens any segment within one hour of the query range (`traceCompletionWindow`), so the neighboring day's spans are no longer silently dropped. Applies to both ORDER BY and trace-ID trace queries; trace selection, ordering, and limit/offset are unaffected. - Fix multi-group Measure aggregations failing with `partial N schema mismatch` when the groups' schemas differ. A projected non-key tag that a group doesn't define is now null-filled before the liaison reduces the partials. - Charge large tag and field values by their size instead of eight times it, so queries that read multi-MB values (for example SkyWalking OAP ai-agent session files stored as a `body` tag) no longer exhaust their memory allowance with `query memory pool exhausted`. - Without `--allowed-bytes` or a container memory limit, size the query memory pool from the host's memory (75% of it, divided by 4, each query getting an eighth) instead of a fixed 64 MiB. The memory protector itself stays disabled: write backpressure, merge budgets and the protector's state are unchanged. - Fix multi-group Measure aggregations dropping a group's contribution when two groups report the same shard id and group key. Replica dedup now keeps storage groups apart. - Report a query that hits the memory budget or an index limit on a standalone or data node as RESOURCE_EXHAUSTED instead of an internal error. - Fix native observability writing a scope label's value under another label's tag name: the tag family and the written tag values were both built by ranging over the scope's label map, in independently randomized orders. The label order is now resolved once per provider and instrument instead of on every metric update. Measures that already exist in the `_monitoring` group keep the tag order they were created with (`CreateMeasure` returns `ErrGRPCAlreadyExists` on upgrade), so they keep the old misalignment until they are recreated. - Report MCP server request timeouts as timeouts: the HTTP client now aborts with a `TimeoutError`, so the client's "Query timeout" and "List groups timeout" messages are shown instead of a generic failure. - Fix FODC `/metrics-windows` failing when an agent's reply exceeds the gRPC message limit. The agent now sends replies in 4MiB chunks that the proxy merges, and a metrics stream error reopens only that stream instead of re-registering the agent. Upgrade the proxy before or with the agents. - Fix tolerate AlreadyExists when concurrent liaisons create the internal deletion task schema. - Stop measure queries from failing with `query memory pool exhausted` when a time-ordered scan merges many series over blocks much wider than the query window, as after a merge. The scan reserved each block as if every row were kept; it now reserves what the in-range rows keep (schema-aware, calibrated against measured decodes), refunds the decode's temporary expansion once the decode ends, copies a narrow window's bytes out of the decoded block so the rest can be freed, and cuts a merge that still would not fit into time slices. Exhaustion errors name the allowance that ran out. A traced measure query gets a `scan-storage` span (decode pool, prefetch, memory budget, rejections) and the scan exports `total_scan_reservation_rejections{reason}`, `query_budget_peak_ratio`, `scan_decode_seconds`, `total_scan_slices` and `total_scan_sliced_units`. - Fix an explicit `ORDER BY` on an index-mode measure ignoring timestamps. `ORDER BY DESC`, `ASC` and `TIME DESC`/`ASC` returned the rows in index order, so `ORDER BY DESC LIMIT n` did not return the newest `n` rows, and the rows of different segments were merged by series ID. An explicit time order now sorts by the row's timestamp before `LIMIT`, within a segment and across segments. A query with no `ORDER BY`, and one that orders by an index rule, are unchanged (apache/skywalking#14218). - Bound the memory a stream ordered query holds for its top-N. The global merge kept every consumed batch alive, and charged it in full, for as long as one retained row pointed into it, so a limit over a wide window and many series held up to two whole batches of rows per retained row and could be rejected with `query memory pool exhausted` while needing kilobytes. The merge now copies the rows it keeps out of sparsely-kept batches into compact ones and refunds the batches they leave; the order, the duplicate-ElementID rule and the results are unchanged. - Keep slow reopens and deletes of cold segments out of the segment controller lock, so a query over an idle-closed segment or the disk monitor's forced cleanup no longer stalls the group's writes. Forced cleanup can now evict idle-closed segments, and a closed or removed segment is no longer reopened or loses a reference held by a reader. ### Document - Document the six release archives (src, banyand, bydbctl, fodc-agent, fodc-proxy, canopy) and their 18 signed files. - Add the [native inverted-index replacement design package](docs/design/archive/0.12.0/native-inverted-index/README.md), including the implementation specification, ICE walkthrough, research plan, and visual report. - Add the [tag aggregation and time bucketing design](docs/design/0.12.0/tag-aggregation/README.md) for the measure query engine, covering aggregation over tags, `COUNT_DISTINCT`, and `GROUP BY` time buckets. - Add mandatory size and TDD-feasibility audits to the BanyanDB GitHub issue skill. - Align cluster and node-discovery port documentation and remove leftover etcd references. - Fix BydbQL reference examples and grammar that didn't parse (clause order, Top-N `ORDER BY`, Property `ORDER BY`), and parse every doc example in the `pkg/bydbql` tests so they can't drift again. - Fix the docs menu: link the Property repair observability page, Node Discovery and Persistence Storage, and mark the tag aggregation design implemented. ### Chores - Upgrade the OAP E2E suites to SkyWalking 5689aa8 and add the AI agent conversations case (`ai-agent`), which stores multi-MB tag values. The yq installer now pins v4.54.1 when the installed yq lacks `tonumber`, and the OAP-based Helm cases drop the UI image, which SkyWalking no longer publishes. - Remove the legacy embedded web UI (`ui/`) from the BanyanDB binaries, Docker images and release packages. Use the standalone [Canopy](docs/interacting/canopy.md) web console instead; the HTTP port (`17913`) now serves only the HTTP API under `/api`. The `-slim` builds now only stub out the memory-pool diagnostic tracking. - Remove accidentally committed local design notes from the repository root. - Remove the accidentally committed `test_table` ELF binary from the source tree. - Update NOTICE copyright year to 2026. - Bump google.golang.org/grpc to v1.83.2 to clear GO-2026-6443, GO-2026-6441, and GO-2026-6348. - Bump canopy and mcp npm dependencies to clear Dependabot CVEs (fast-uri, fastify, qs). - Bump mcp/canopy npm deps (hono, js-yaml, vitest 5) to clear Dependabot CVEs. - Bump the pending mcp npm dependencies (`fast-uri` 4.2.1, `ip-address` 10.7.3, `proxy-addr` 2.0.8, and the `brace-expansion` 5.0.12 dev dependency) and regenerate the committed `mcp/LICENSE`, so `make check-req` passes on the Dependabot PRs that only edit `package-lock.json`. - Bump `go-chi/chi/v5` to v5.4.0, `go-jose/go-jose/v4` to v4.1.7 and `golang.org/x/net` to v0.62.0, and the canopy and mcp npm dependencies (`fastify` 5.12.8, `undici` 7.30.1, `fast-uri` 3.1.9 / 4.2.3, `@modelcontextprotocol/sdk` 1.32.2, `zod` 4.6.7, `hono` 4.13.16, `@hono/node-server` 2.1.6, `body-parser` 2.4.0, `qs` 6.17.1, `ip-address` 10.7.5, and the `vite` / `vitest` dev dependencies) to clear Dependabot and OSV CVEs, regenerate `dist/LICENSE`, `mcp/LICENSE` and `canopy/LICENSE`, and move the E2E workflows to skywalking-infra-e2e 56ac8be. - Stop `test-build-system.yml` reporting a version drift when the image carries the pinned version: `grep -q` inside a pipeline exited on its first match, SIGPIPEd the writer, and GitHub's default `bash -eo pipefail` turned that into a pipeline failure. The same pipeline shape hid a real regression in the "no version literal" check, where a false 141 skipped the check. Both now read from a here-string, and the platform probe no longer ends in `head -1`. - Merge the per-group results of a local multi-group Measure query as columnar batches (`vecplan.DispatchBatches` and `MultiGroupMerge`, built on the liaison row merger) instead of through the row merger, and remove `MergeGroupMIterators`, `sortableDataPoints` and `sortedMIterator`. Hidden criteria tags are stripped once, after the merge, and the trace plan string now reads `vec-multi-measure-batch[...]`. The query `offset` is applied once to the merged rows instead of to each group before the merge. Index-order merging now also handles null and array tag values, and the retained batches are charged to the query memory budget. Aggregation and the wire formats are unchanged. - Bump `go.opentelemetry.io/otel`, `otel/metric`, `otel/sdk`, `otel/sdk/metric` and `otel/trace` to v1.47.0 to clear GHSA-q7gw-24fr-5p69, regenerate `dist/LICENSE`, and move the E2E workflows to skywalking-infra-e2e 7268db1. ## 0.11.1 ### Bug Fixes - Enforce the Canopy readonly role on the `/monitoring/*` proxy the same way as `/api/*`. ## 0.11.0