Skip to content

Edge edge-20261020-fb984d2

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 20 Oct 06:27
· 216 commits to main since this release
fb984d2

Edge build of fb984d2 from main, published as edge-20261020-fb984d2. Edge builds are prereleases built once a day from a commit on main whose CI passed; they do not receive the qualification a stable release does. The latest stable release is v0.13.0.

Compatibility

This build v0.13.0
Version 0.14.0-edge+fb984d2 0.13.0
Storage format written 16 14
Storage formats served v14 to v16 v14 to v14
HTTP contract 0.13 not reported

Storage. A branch this build writes to is left at storage format 16, which v0.13.0 cannot open. Test on a copy of the graph, or back it up, before pointing this build at data that v0.13.0 must still read.

HTTP. This build speaks HTTP contract 0.13. v0.13.0 does not report its contract; its release notes name it.

Install this build

curl -fsSL https://raw.githubusercontent.com/ModernRelay/omnigraph/main/scripts/install.sh | VERSION=edge-20261020-fb984d2 bash
iwr -UseBasicParsing https://raw.githubusercontent.com/ModernRelay/omnigraph/main/scripts/install.ps1 -OutFile install.ps1
powershell -NoProfile -ExecutionPolicy Bypass -File .\install.ps1 -Version edge-20261020-fb984d2

Every archive carries a build provenance attestation: gh attestation verify <archive> --repo ModernRelay/omnigraph checks that this repository's release workflow built it from fb984d2.

Unreleased changes

Release notes recorded since the last stable release, as v0.14.0 will publish them.

Upgrade actions

  • Branch names are used exactly as written. A name with leading or trailing
    whitespace or a control character is now refused as a bad request wherever
    a branch is named (HTTP routes, CLI commands and embedded engine calls), as
    branch statements already refused it; such a name used to be trimmed, so
    main named main. Clients that send padded names must send the exact
    name. A policy whose protected_branches lists such a name now fails
    validation. See branch names.
  • The CLI no longer reads OMNIGRAPH_BEARER_TOKEN. It used to send that
    token to any remote server a command addressed, including a literal
    --server https://… URL the operator does not control. A token now reaches
    only the server it is keyed to: a request to a URL under a server declared
    in ~/.omnigraph/config.yaml carries that server's token, and any other
    request carries none. When such a request gets HTTP 401, the CLI names the
    server to declare or the omnigraph login command to run; --json output
    carries this as missing_credential beside the server's unchanged error.
    The server's own OMNIGRAPH_SERVER_BEARER_TOKEN* settings are unchanged.

    If you export OMNIGRAPH_BEARER_TOKEN for the CLI, declare the server under
    servers: and bind its token with omnigraph login <name>, or set
    OMNIGRAPH_TOKEN_<NAME> (the name uppercased, - written as _). In CI,
    write a config.yaml with the server's url into $OMNIGRAPH_HOME and
    pass the secret as OMNIGRAPH_TOKEN_<NAME>. Address the server by name
    (--server <name>) or by a URL under its url. Managed credentials
    (omnigraph login --api, OMNIGRAPH_CONTROL_TOKEN) are unchanged. See
    server credentials.

  • Saved query plans now use envelope version 9, which records each correlated block's strategy. Regenerate plans saved with earlier binaries; older binaries reject version 9 plans.

  • Saved query plans now use envelope version 7 to preserve distinct-count semantics. Regenerate plans saved with earlier binaries; older binaries reject version 7 plans.

  • Vectors written by an earlier omnigraph embed embed the templated text
    rather than the source value and match text queries poorly. Regenerate them
    with omnigraph embed --reembed-all and load the result again. An embedding
    spec, including a seed manifest's embeddings entry, must now list exactly
    one property in fields, the source its @embed declares; a spec that
    lists several is refused, and so is a source value that is not a string.
    See the offline file pipeline.

  • Consumers of saved explain documents must accept explain_version 5 and its new pipeline shape: pipelines entries now carry identity, a pipeline id and depends_on naming the build pipelines drained before it starts, with source, operators and sink as objects whose id joins the physical_plan node ids. The push executor builds from the same decomposition the document serializes, so the printed pipelines are the executed ones. The additive logical_plan_initial field holds the logical plan as resolved, before rewrite passes ran, and explain output prints it as the logical_initial tree.

  • A full-text call (search, fuzzy, match_text, bm25) on a String
    property the schema does not index is refused at type checking (T27).
    Such a call used to scan with a bare, case-sensitive tokenizer, so
    search($d.notes, "deep") missed "Deep Learning" while the same call on
    an @index property matched both spellings. Declare @index on the
    property; every write then records the index's analyzer. An enum takes no
    full-text index: compare its values with =.

    Stored queries are recompiled when a server starts, and a refused one
    quarantines its graph. Run omnigraph queries validate and
    omnigraph cluster plan before upgrading, and treat a T27 finding as a
    pre-upgrade fix. See the search guide.

  • Managed login and folder context now use version 2 and select an organization
    explicitly or from a bound folder. Separate organizations keep separate device
    sessions; ambiguous selection refuses, running commands keep the same verified
    identity, and logout clears only the selected organization's control credentials.
    Existing managed users must sign in and bind their folder again. Direct access,
    named-server credentials, graph HTTP contracts and storage formats are unchanged.

  • A branch's __manifest now keeps a block registry of its released history:
    one history_block row per released run of a __history block and one
    history_merge row per merge commit inside it, so a cold branch merge
    crosses released history without reading its blocks and reads __history
    only for commits no row covers and for final candidates tied on distance
    and generation.
    Rows beyond the newest 64 live in fragments of __manifest that a publish
    reuses; a push of new registry rows can repack smaller cold fragments. This is
    storage format 15: a format 14 graph is served as it is and each branch is
    stamped 15 by its first publish under this binary; binaries that only read
    format 14 then refuse the graph, so upgrade every binary before the graph. No backfill
    exists or is needed: a merge reads blocks as before until they gain rows.
    The offline omnigraph upgrade converts a standalone format 8, 9 or 13
    graph to 15 and its routes are named history-lance-files-v8-to-v15,
    history-lance-files-v9-to-v15 and history-lance-files-v13-to-v15. See
    the upgrade guide.

  • New schema declarations interpret @range(p, ..max) as an inclusive
    maximum and reject integer bounds outside I64 instead of rounding them
    to F64. Existing accepted graph schemas retain their stored bounds;
    before reapplying or importing their source, write an old upper-only bound
    as min.. and an oversized integer bound as a decimal with its recorded,
    possibly rounded value. Complete outstanding deployments containing
    affected source before upgrading the binary. See range constraints.
  • A graph whose schema declares @range on a list property now refuses a
    load, mutation or merge that writes a list element outside the range,
    with @range violation; the declaration was not enforced before. Rows
    already stored are left as they are. Writers that relied on the unchecked
    declaration must keep elements inside the range: schema migration refuses
    removing a constraint from a property that stays.

Features

  • A Boolean expression over aggregates, literals, now() and parameters in an aggregated return, such as count($p) > 0 as has_member, is evaluated per group after aggregation and projects a Bool column under its alias (Bool? when an operand can be null); the alias is an order key. A group value beside an aggregate in such an expression is refused (T58). See Return, order, and limit.
  • The shared benchmark catalog no longer pins APFS and clonefile in its defaults:
    a scenario without an explicit environment takes the host's local default
    (APFS with clonefile on macOS, qualified XFS with plain-copy elsewhere), so one
    benchmarks.yaml runs on a workstation and on an XFS NVMe lab. The resolved
    backend stays part of the point identity.

  • branch-merge-d50-history64-xfs (group aws-xfs-history64) measures the D50
    merge on a fixture aged by 64 reversible single-row update commits before the
    branches are created, declared for XFS like branch-merge-d50-process-cold-xfs.
    It is a new identity; no timing equivalence to the retired branch-merge-v1
    history recipe is claimed.

  • An embedded Session can replace or clear one Blob value of an existing
    node or edge by exact id with put_blob_at_as and clear_blob_at_as. Each
    write is one graph commit under the change action, never reads the old
    value, and carries the row's other cells as an update does. An optional
    precondition, BlobPrecondition::Tags (the current ETag is one of the given
    tags) or BlobPrecondition::AnyExisting (the cell is not null), fails with
    BlobWritePreconditionFailed, which names the current ETag, and changes
    nothing. A put returns the value's length, its ETag and the commit; the ETag
    is the one a read at that commit reports. One put holds at most the
    session's write_max_bytes (32 MiB by default), inclusive; a larger one
    fails before any table is opened with resource Blob write payload bytes.
    The HTTP server exposes them as PUT and DELETE /blob, and the CLI as
    blob put and blob clear.

  • omnigraph blob put ENTITY TYPE ID PROPERTY stores the raw bytes of
    --file PATH or stdin in one Blob cell, and omnigraph blob clear sets a
    nullable cell to null, on a --store graph or a served one. Both take
    --branch, --if-match TAG (* or entity tags) and --json, and print the
    receipt the server returns: the selector, branch, state, size and ETag of a
    managed value, the actor and the exact commit, which is null for a clear of
    a cell that was already null. Input over 32 MiB and a malformed --if-match
    are refused before the graph is addressed, and an interactive stdin is
    refused rather than waited on. --as names the actor of a --store write.
    A served Blob precondition failure exits 4, as a graph-commit one does; an
    embedded one exits 1. A write is sent once and never retried.

  • PUT and DELETE /graphs/{graph_id}/blob replace or clear one Blob value
    of an existing node or edge, each as one graph commit under the change
    action. PUT takes a raw application/octet-stream body of at most 32 MiB,
    inclusive (415 for another media type, 413 over the limit, refused
    before reading when Content-Length declares it, 408 past the body
    deadline). Both take branch, default main, refuse snapshot, and accept
    If-Match: * or a list of entity tags. A failed If-Match is a 412
    with the new blob_precondition_failure.current_etag detail and an ETag
    header naming the cell's current value. Success returns a receipt with the
    selector, branch, kind (managed or null), size and etag, the actor
    and the exact commit, which is null only when clearing a cell that was
    already null. A PUT also returns the ETag header.

  • A fresh, empty S3 cluster initialized through omnigraph-cluster::bootstrap_serving can transfer its retained ownership to the first server with --bootstrap-handoff FILE. The bounded, exact receipt is checked before listening; failed or replayed claims never fall back to ordinary startup. See first boot from a bootstrap receipt.

  • branch create starts a branch at a past graph commit: --from-commit on
    the CLI, from commit "<id>" in the branch create statement (GQ language
    version 2.3) and from_commit on POST /branches. The new branch holds that
    commit's rows and history, so a fix or revert can be tried where a change was
    made and merged back with the commit as its base. A commit cleanup no
    longer retains (410), one written under an earlier schema or before the
    storage upgrade, one whose branch was deleted, an unpublished commit and an
    unattached snapshot (409) start no branch; the new branch_start_refusal error detail names the
    reason. Every branch creation receipt now carries from_commit_id, the
    commit the new branch starts at, and the CLI prints it:
    created branch <name> from <branch> at <commit-id>. See
    Start a branch at a commit.
  • omnigraph version --json prints the package version, the HTTP contract the
    CLI sends (http_contract, the exact Omnigraph-Http-Api value a server
    requires) and the storage-format stamp it writes with the inclusive range it
    serves (internal_schema.writes, internal_schema.serves), without
    contacting a server, so a program can choose among installed CLIs. The text
    output gains a third line, http-contract 0.13. See Verify.
  • Page through a branch's commit history. GET /commits takes limit
    (1 to 1,000) and an opaque page_token, and omnigraph commit list takes
    --limit and --page-token; the MCP commits_list tool takes both too. A
    page returns head_commit_id, the head its listing resolved, and a
    next_page_token while older commits remain; later pages answer for that
    head even after the branch moves. A page reads only the history it returns,
    so its cost no longer grows with the branch's history. Under a policy, a
    caller whose read does not cover every branch continues only from a commit
    of the branch's history; one it holds or a readable branch published costs
    nothing more, and any other is looked for down the whole history. Without
    either
    parameter the whole history is listed as before. See
    commits.
  • count(distinct $x) counts distinct nodes by identity and count(distinct $x.prop) counts distinct non-null values, grouped or ungrouped, in return and as an order key; plain count keeps counting rows. distinct under sum, avg, min or max is refused (T57). See Return, order, and limit.
  • Edge builds are now made once a day from the tip of main once its whole
    CI run passes, and each is published as its own prerelease,
    edge-<commit date>-<commit>, whose archives never change, so a deployment
    can pin it with VERSION=edge-… (-Version on Windows) and return to it
    later. The 30 newest are kept, and so is the newest build of each storage
    format, which can still export a graph written at that format. The rolling
    edge release still holds the newest build.
    Each edge release lists the storage format and HTTP contract the build uses
    next to the latest stable release's, and says when a stable binary could no
    longer open a branch the build writes to. See
    release channels.
  • Every edge build is now also a container image with the build's tag, such
    as modernrelay/omnigraph-server:edge-20261016-9c2b367 on Docker Hub and on
    GHCR. It packages that build's released Linux x86_64 binaries on Debian
    trixie, carries a build provenance attestation, and an edge image tag
    follows the rolling edge release. latest still names the newest stable
    release. See release channels.
  • The engine catalogue: five built-in read-only node types (@Operator, @Pass, @Setting, @Engine, @LogicalKind) answer GQ reads from the running binary's registries, beside a graph's own types or under the store-free scope og_catalog (--store og_catalog, --graph og_catalog, policy target og_catalog). Writes and text search over them are refused; schema show og_catalog lists them. Ordinary schema show preserves the graph's reusable schema source. See Engine catalogue.
  • The process setting explain_dump_dir (environment default OMNIGRAPH_EXPLAIN_DUMP_DIR) names a directory the planner writes each finished explain document into, one <operation>_<logical_hash>.explain.json per operation and logical hash, with each replacement publishing a complete document atomically. Empty, the default, disables the write; a failed write reports on stderr and never fails the operation. See Session settings.
  • A full-text call on a declared index that has no part at the query's
    snapshot, in a table version an older release wrote and never indexed, is
    refused before any scan with HTTP 409 and a full_text_index_required
    detail naming Type.property, instead of answering case-sensitively.
    Building the index lifts it: omnigraph optimize on main, or
    omnigraph rebuild-full-text-indexes --branch <branch> elsewhere. See the
    search guide.
  • GQT files can omit schema and seed together and run against an existing
    local, S3-compatible or Azure store with omnigraph-gqt --store <URI>;
    dataset-only files may have zero steps. External-store reports cannot replay,
    and --measure requires a selected DST environment. See the
    GQT runner guide.
  • GQT supports bounded, deterministic generate: v1 seeds and append or keyed
    merge load steps, including explicit commit partitioning, vectors and uniform
    or Zipf endpoints. Generated loads share normal branch, restart, expectation
    and fault-injection behavior, so benchmark datasets can live in .gqt files.

  • Generated seeds preserve blank lines in YAML block strings. Shared GQT YAML
    admission rejects duplicate mapping keys, aliases, anchors, tags and merge keys
    using syntax tokens while preserving literal punctuation in scalar values.
    Mapping keys must be strings, so a plain true or 1 key is refused instead
    of silently merging with its quoted twin; admission errors name the section.
    A YAML section body keeps its final line break, so a block scalar ending a
    recipe loads the newline the file shows, and # lines inside a generated
    recipe are YAML text rather than refused comments.

  • GQT steps can generate their parameters: --- params generate: v1 seed: <u64> holds a YAML params: map from each parameter to one column
    generator, evaluated at ordinal zero, in place of a JSON body. A new blob
    column ({kind: blob, byte: <0-255>, length: <bytes>}) produces the
    base64: input of a managed Blob, in generated parameters and generated
    loads alike. A parameter recipe names at most 256 parameters within a
    64 MiB JSON bound, takes no ${ substitution, and is generated when its
    step runs, so a case can pass a 32 MiB Blob without carrying its text.

  • The GQT runner executes a case against a running omnigraph-server with --server <URL> --graph <ID> (optional --token): every step travels to the route that already serves it and is judged from the answer; a case opts in by declaring the omnigraph-server target, which stays unselected without --server. The served conformance test runs every opted-in corpus case through an in-process server and requires the in-process verdict; see the runner guide.

  • omnigraph-gqt --trace records GQT steps, assertions, every decision seam crossing with the decider's answer, and available engine spans/events in a bounded JSONL file per DST attempt, one flat row per line with the owning step on every row and a checked-in schema. Trace files survive worker failures and remain separate from replay comparisons. See the GQT runner guide.
  • Ask a graph what your credential may do. GET /graphs/{graph_id}/access
    and the MCP access tool return the caller's actor, the actions its
    credential allows on the whole graph, and, for a named branch and target
    branch, the actions allowed there, decided by the installed policy exactly
    as the routes that perform them decide. See
    Learn your access.
  • Compare two points, review a branch, and preview a merge. Each is a GQ
    branch statement at POST /query and omnigraph query, with a CLI command
    and HTTP route that wrap the same engine call:

    • branch diff <from> to <to> (omnigraph diff --from --to, GET /diff)
      reports the net entity changes between two branches or commits, in the
      commit changes change shape and without a cause;
    • branch diff <branch> [into <target>] (omnigraph branch diff,
      GET /branches/diff) reports what a branch changed since its merge base;
    • branch merge-base <branch> [into <target>] (omnigraph branch merge-base, GET /branches/merge-base) names that base;
    • branch merge <branch> [into <target>] dry run (omnigraph branch merge --dry-run, dry_run: true on POST /branches/merge) reports the outcome
      or the conflicts a merge would have and writes nothing; it needs read on
      both branches, not branch_merge.

    A branch diff statement answers one row per change and carries the
    compared commits and its continuation token in a new optional page object
    on ReadOutput; after page "<token>" continues it. See
    changes, diffs and change feeds and
    previewing a merge.

  • load csv imports one authorized CSV object into a declared node or edge type through mutate, with values typed by the schema and bounded input admission. See CSV loading.
  • explain accepts a load csv statement and prints the planner's document
    for it, the same shape and explain_version 6 a query's explain prints,
    without reading a payload byte; see the explain guide.
    An overwrite load runs that plan through the engine's load operators.
    A GQT load step takes an --- expect plan section, checked against the
    executed load's document (plan expectations).
  • The load csv source bound is now the load_source_max_bytes session
    setting
    (request scope, at least 1, unchanged
    32 MiB default, OMNIGRAPH_LOAD_SOURCE_MAX_BYTES supplying the process
    default) instead of a hardcoded 32 MiB constant. A source over the setting
    is still refused as csv_source_bytes before any payload byte is read, and
    a served load's workload-admission reservation follows the request's value.
  • Discover accessible clusters with cluster list --managed, then download an
    exact configuration revision with cluster pull --managed --out NEW_DIR.
    Downloads preserve existing local work and include the folder binding for
    subsequent edits, pushes and deployment. See managed clusters.
  • omnigraph cluster members list --managed lists explicitly enrolled cluster members using the selected organization's cached session and existing status permission. It supports a readable table and --json; graph permissions remain governed separately by applied Cedar policy. See the CLI reference.
  • Managed organization administrators can invite teammates, inspect the membership directory, apply versioned cluster-access patches and offboard users through organization --managed (org). Writes require an explicit idempotency key, and graph permissions continue to use applied Cedar policy. See team administration.
  • /mcp serves the agent skill's query, data, schema, search and change-feed
    references as omnigraph://best-practices/* resources, with an index, so a
    model can read the guidance that matches the server's version. See
    MCP.
  • /mcp is now mounted whenever the server has a bearer credential source
    (static tokens, signed data tokens or OIDC), so a self-hosted server reaches
    Claude Code, Cursor and other MCP clients with its existing token; OAuth
    discovery stays OIDC-only, --mcp-allowed-host admits extra Host names, and
    without OIDC any request carrying an Origin header is refused.
    New read tools health, snapshot, branches_list, commits_list,
    commits_get, commits_changes and changes_poll, and resources for the
    graph list and each graph's schema and branches, call the same handlers and
    policy actions as their HTTP routes. Write tools mutate, load,
    branches_create, branches_delete and branches_merge are listed only with
    --mcp-allow-writes; they never retry, honour if_graph_commit, and report
    outcome_unknown instead of guessing. See MCP.
  • The server's /mcp endpoint gains a schema tool, which returns a graph's
    .pg schema under the read action, and an opt-in read tool, which runs an
    ad-hoc GQ read through POST /query, refuses mutations, and is listed only
    when the server starts with --mcp-allow-adhoc (or
    OMNIGRAPH_MCP_ALLOW_ADHOC=1). Tools now carry titles, fuller descriptions
    and, where the result shape is fixed, an output schema, and initialize
    returns instructions that tell a model to read the schema first. See
    MCP.
  • Protected-resource metadata is also served at the path the /mcp challenge
    advertises (/.well-known/oauth-protected-resource/<resource path>), so an
    OAuth client such as Claude connects to a resource identifier with a path
    without a proxy rewrite, and a refused bearer token now gets
    error="invalid_token" in that challenge.
  • Every read plan is checked against the query before it runs, and explain
    reports what the check covered in a validation field: exact_subset for a
    single-binding query with property filters, an optional leading bm25(),
    property sort keys and a limit, whose every rewrite was checked, and
    invariants_only for every other query. See the explain
    guide
    .
  • The per-query memory pool is now the query_memory_bytes session
    setting
    (request scope, at least 1, unchanged
    150 MiB default, OMNIGRAPH_QUERY_MEMORY_BYTES supplying the process
    default) instead of a hardcoded constant. set query_memory_bytes = … in a
    statement prefix or the request's settings field sizes that one query's
    pool, and explain's assumptions.memory_limit reports the value in effect.
    Operators that cannot spill refuse work beyond the pool; spillable operators
    may use bounded scratch storage.
  • The release archives now include the server's AWS Secrets Manager
    bearer-token source (OMNIGRAPH_SERVER_BEARER_TOKENS_AWS_SECRET), as the
    container image already did, so a server from an archive, the stable image
    and the edge image accept the same token configuration. See
    HTTP server.
  • Release archives and the container image now name the commit and channel
    they were built from. omnigraph version prints a commit line, --json
    adds channel and commit, and an edge build reports a pre-release version
    such as 0.14.0-edge+9c2b367, which sorts after the latest stable release
    and before the release it precedes. The server reports the same version on
    GET /healthz and in its MCP server info, and the commit as
    source_version. Every
    archive and the image's GHCR digest also carry a build provenance
    attestation that gh attestation verify checks. See
    Verify.
  • return distinct { … } keeps one row per distinct projected tuple: repeated matches and equal values on different entities collapse, nulls compare equal, and deduplication precedes order and limit. Order keys after any leading search function must be projected values or aliases; remaining projected values break ties. A search function without subsequent keys selects the input population but leaves the distinct results unordered. See Return, order, and limit.
  • omnigraph-bench can measure read-only GQT workloads against an externally provisioned omnigraph-server, with served query and traversal scenarios. A run needs a typed deployment receipt and a graph provisioned for the scenario's fixture recipe. Served records separate declared server evidence from observed client evidence, preserve unavailable server counters as absent, and remain ineligible for performance claims. See the served acquisition guide.
  • --server unix:///absolute/path.sock, or a server url: of that form in
    ~/.omnigraph/config.yaml, reaches a server through a Unix-domain socket, for
    example a local gateway that a sandboxed agent may reach when it has no TCP
    network access. The CLI sends the same HTTP/1.1 requests over the socket,
    with the same /healthz discovery, contract header, bearer token, and
    no-redirect and no-retry rules as over TCP. Unix platforms only. See
    Use a server through a Unix socket.
  • omnigraph skill export DIR writes the omnigraph agent skill built into the binary, so an agent reads the skill written for the CLI it runs. It refuses to replace existing files without --force, records what it wrote so a later --force export removes only unchanged files the skill no longer has, and with --json reports the files written, skill_version, cli_version and http_contract; omnigraph skill show [PATH] prints one skill file. See the CLI guide.
  • Query explain now lists declared result column names and types for projections, aggregates and metadata counts. Saved bound plans use version 3 and retain complete node-object types for replay validation; regenerate version 1 or 2 plans. See the explain guide.
  • The benchmark catalog measures a write as an unattached branch root beside its named-branch twin: tiny-mutate-unattached (the tiny insert), very-long-history-32-write-unattached (the next update on 32 published updates) and unattached-chain-32-write (the next root beside a retained 32-snapshot chain), each verified at its snapshot, with main unchanged, and dropped. These records cost the root write only; a chained child is not a selectable step, and per-phase attribution stays merge-only.

  • Unattached graph branches (RFC "Unattached graph branches"): a mutation
    declaration may end in as unattached branch, optionally on "<id>" or
    on $base, which writes the complete result as an unattached snapshot,
    readable by its graph commit id (kind: "unattached", published: false
    and root_commit_id on the receipt's commit), invisible to every branch
    read, and extendable by a further write on it; the caller holds the
    latest id as its tip, and two writes on one base each get their own
    snapshot. A snapshot never publishes: commit publish "<id>" and
    POST /commits/{commit_id}/publish answer 409 with the error code
    unattached_cannot_publish. commit drop "<id>" and
    DELETE /commits/{commit_id} drop the snapshot and every snapshot built
    on it; GET /commits?unattached=true&branch=<name> and the CLI's
    commit list --unattached list a branch's live snapshots, newest first.
    Every snapshot of a chain expires when its branch head moves past the head
    the first write captured or the branch is deleted. Writing is a change on
    the recorded branch; a child accepts an omitted branch and refuses an
    explicit branch that differs from its base's target, including main.
    Listing and snapshot reads need read on that target. Missing ancestry
    prevents reads, extension and drop and retains the snapshot during cleanup.
    CommitOutput gains kind and root_commit_id; clients infer legacy
    receipts' kind from published when the kind field is absent. A graph born by this release is stamped
    internal schema v16; v14 and v15 graphs stay served and refuse
    as unattached branch until omnigraph upgrade stamps their live branches.
    GQT cases name a bound snapshot in as unattached branch on "${name}".

  • Unpublished graph commits (RFC "Unpublished graph commits"): a mutation
    declaration or a branch merge statement may end in as commit, which
    writes the complete result as an unpublished commit, readable by its graph
    commit id (published: false on the receipt's commit) and invisible to
    every branch read, until commit publish "<id>" installs that exact result
    on its recorded target branch or commit drop "<id>" removes it. Both are
    control writes through POST /mutate and have routes of their own,
    POST /commits/{commit_id}/publish (the published commit) and
    DELETE /commits/{commit_id} (204); GET /commits?unpublished=true lists
    a branch's unpublished commits, POST /branches/merge takes as_commit
    (exclusive with delete_branch), and the CLI gains commit publish <id>,
    commit drop <id>, commit list --unpublished and branch merge --as-commit. CommitOutput gains published.
    Two Cedar actions, commit_publish and commit_drop, gate the control
    writes by the recorded target (target_branch_scope). A graph born by this
    release is stamped internal schema v15; v14 graphs stay served and refuse
    as commit until omnigraph upgrade stamps their live branches. GQT cases
    bind a write's commit id with --- bind commit $name, read it with
    --- query snapshot: $name, and name it in commit publish "${name}" /
    commit drop "${name}".

  • Bounded writes now accept the write_max_bytes session setting,
    from 1 through 33554432 bytes (the unchanged 32 MiB default), with
    OMNIGRAPH_WRITE_MAX_BYTES supplying the process default.
    Row data and logical Blob payloads have independent allowances, so a Blob exactly
    at the limit can accompany scalar metadata that fits its own allowance.
    The default now admits up to 32 MiB of row data plus 32 MiB of Blob payload
    per operation, where the previous single 32 MiB allowance covered both.
    HTTP body, Blob read, compaction and URI metadata limits remain independent.

Behavior changes

  • Correlated block aggregates now use the same result types as return
    aggregates: integer sum accumulates exactly in 128 bits and rounds once
    to F64 before comparison, avg converts each input to F64 before
    accumulation, min and max retain the column's type and full U64 range,
    and counts refuse values beyond I64.
    A single integer sum of 9007199254740993 therefore no longer satisfies
    > 9007199254740992 after rounding.
    Regenerate saved bound plans; see the query guide.
  • A named traversal whose hop bound allows more than one hop is refused with
    T5 when its edge connects two different node types, as in
    $p worksAt{1,2} $c for WorksAt: Person -> Company. No path over such an
    edge continues past its first hop. Before, such a range was capped at one
    hop without a word: {1,n} returned the one-hop rows, and a range starting
    above one, such as {2,2}, returned none. For {1,n}, omit the bound or
    write {1,1} to keep the same rows. A range starting above one never
    matched anything, and dropping its bound would return the one-hop rows
    instead, so check which path the query meant. A stored query with such a
    bound now fails type checking, which omnigraph queries validate reports.
    See traversal and match patterns.
  • Dropping a property no longer rewrites its table. Through v0.13.0 schema
    apply rewrote the table without the dropped values, so omnigraph cleanup alone
    erased them; now they stay in the table's data files until
    omnigraph optimize rewrites every fragment that holds them, whatever its
    size. To erase them, run optimize, delete every branch created from a commit
    before it and every tag naming such a commit (merging a branch does not
    release its files), then run cleanup with a retention that excludes the
    commits before the optimize, for example --keep 1. Dropped types are still
    reclaimed by cleanup alone. See
    dropping declarations.
  • Development builds now report package version 0.14.0, distinguishing the
    current edge binaries from the 0.13.0 release. The HTTP contract remains
    0.13; the package version bump does not change storage compatibility.
    See checking the installed version.
  • Benchmark cases now use gqt-v1 dataset/query pairs with an ordinal and exact
    operation echo. The release harness builds a persistent verified dataset cache,
    derives cache treatment from preparation reads/reopen, and measures one selected
    engine operation before GQT expectations and verification. Named scenario groups,
    raw dataset build/dataset validate, and explicit dataset/query invocations
    share the same worker and archive pipeline. Registered FinBench and D50 cases
    use GQT; the old authored branch-merge-v1 runner and fixture run-graph command
    are retired. Historical run records preserve their canonical bytes and remain
    queryable beside typed GQT records. New logical identities and warm-up programs
    do not claim identical points or comparable timings to the retired recipes.

  • The GQT catalog adds bounded history, idle-table/branch, multi-table mutation,
    branch-name reuse, separate row/branch churn, configured history-release, and
    equal-current/different-history pairs with exact post-operation and restart
    checks. Explicit 1,000/10,000/100,000-update history recipes remain opt-in and
    do not imply completed scale or performance measurements.

  • Registered dataset identity preserves exact floating-point values associated
    with exported IDs. Cache quarantine markers refuse symlinks without following
    them. Acquisition rejects receipt budgets that cannot fit the archive before
    dataset work, and recording errors retain one completed prefix alongside the
    failed repetition's diagnostics.

  • The benchmark catalog now separates fixtures/ from workloads/ and uses
    one benchmarks.yaml. Run a scenario by name or pass custom YAML with
    --config. list, show, read-only cache status/cache list, init and
    human/JSON help make inputs, operation selectors and cache state discoverable.
    Legacy case/suite readers and historical records remain supported.

  • The catalog adds 33 bounded end-to-end merge, load, branch, search, query and
    traversal scenarios with exact results and reopened verification. Former Rust
    benchmark entry points are retired. Unsupported maintenance, concurrency,
    HTTP, history/physical-observation and scale instruments are preserved under
    benchmarks/deferred/, outside Cargo discovery. Cleanup and optimization await
    GQ support; no separate GQT maintenance commands are added. New bounded
    scenarios have distinct experiment identities and timing series.

  • OmniGraph now uses Lance 13.0.0 while retaining graph storage format 16 and stable V2_2 data files. Format-16 graphs need no storage conversion; existing full-text analyzer checks and bounded Blob reads and compaction remain in effect. See the Lance compatibility contract.

  • Run only omnigraph cleanup against graph storage. Lance 13's own cleanup can delete files used only by detached versions once those files are older than seven days, leaving manifests present but affected snapshots—including the current graph—unreadable. This also applies to the __manifest catalog. See cleanup.

  • One load csv statement's retained source, decoded batches, validation
    state and staging working set share one query_memory_bytes
    allowance, and a statement it cannot hold refuses before any fragment write.
    write_max_bytes bounds each staged-write input of a CSV load, an overwrite
    batch refusing as staged_write_input_bytes, and the whole-statement
    strict_input_arrow_bytes check applies to JSONL loads alone.
    A source replaced between its metadata probe and its read refuses as an
    external-source error with nothing staged (CSV loading limits).
  • Managed cluster commands now use immutable previews and native deployment
    delivery. Apply uses data.preview_id; exact delivery status supports
    --wait, and cancellation is limited to queued, never-attempted delivery.
    Managed history is bounded to 100 entries. JSON and exit codes follow the
    managed deployment contract; direct commands
    and cloud lifecycle outcomes are unchanged.
  • An MCP write tool now waits 30 seconds for its result instead of 60, below the
    MCP TypeScript SDK's default 60 second request timeout, so a client on that
    default receives the outcome_unknown answer instead of timing out first. The
    write itself still runs to completion. The server instructions now say that a
    missing response is also an unknown outcome and how to reconcile it, and that
    graphs needs a graph_list permit for a credential that is not an identity.
    See MCP.
  • Writes and deletes on a merge's source branch no longer wait for the whole
    merge. A merge holds its source branch only while it captures the source,
    then publishes that captured state; changes made to the source afterwards
    reach the target with the next merge. A merge still waiting for its target,
    because another merge into that target is running, can hold its source
    until it starts. Merges from one source into several targets now run at
    the same time. Merges into one target still run one after another.

  • Servers on local storage and S3 release their writer admission after a proved
    clean shutdown, so the next server can start normally. Uncertain storage work
    still blocks clean restart. Initial bootstrap receipts are one-use; later
    starts use ordinary --cluster. Older tools refuse the new released S3 lock
    record. See shutdown and writer ownership.

  • A return alias can follow the leading nearest(...) order key as a
    secondary sort, as in order { nearest($d.embedding, $v), name desc }, the
    way it already could after bm25(...) and rrf(...). The compile refusal
    T18 ("alias-based ordering is not supported together with nearest") is
    withdrawn from the diagnostic catalog; its number is not reused. See
    return, order, and limit.
  • A returned expression over nearest(...), bm25(...), or
    rrf(...) can also be repeated directly as a secondary order key, without
    failing with "the planned sort key is not a property or an alias".
  • An rrf() whose arms rank two bindings one traversal connects is now a type
    error, T59, carrying the refused expression, instead of the planner code
    P005. The planner codes P001 and P005 are withdrawn; a client matching
    on either reads T59 for the rrf() shape. See the diagnostics
    guide
    .
  • An rrf(...) order now follows the one total order every search order has (RFC 0047): rows sort by the fused score, then the keys written after rrf(...), then every binding's id, and limit counts rows after that order instead of fused entities. rrf(...) is projectable in return under the same rule as nearest and bm25 (T33), as an F64 named <var>._rrf without an alias; the T37 refusal is withdrawn. A search-led aggregate orders its groups by the keys after the search function, then every group key. asc on a bm25(...) or rrf(...) order key is refused (T54). .gqt cases may expect ordered an rrf()-led order and a search-led aggregate order with a key after the search function.

  • A served CLI write that the server refuses with 401 unauthorized,
    403 forbidden or 400 api_contract_mismatch now reports
    command_outcome not_started, none and refresh instead of unknown,
    unknown and reconcile. The server answers these before it admits the
    write, so there is no outcome to reconcile; the exit code stays 1. See
    failed data-write commands.

  • The server logs Lance's lance::dataset_events and lance::file_audit
    targets only at warning and error, whatever RUST_LOG says, as it already
    does for rmcp. At info they logged every table's storage URI, every file
    Lance created or deleted, and each delete predicate with its entity IDs.
    Embedders using their own subscriber should apply the same filter. See
    server logging.
  • Numeric comparisons now use the same compiler-selected types in scan
    filters, in-memory expressions and mutation predicates. A literal narrows
    to a property's type only when its value is exactly representable;
    parameters use their declared types. Comparing an F32 property storing
    0.1 with the F64 literal 0.1 therefore no longer matches only on the
    scan path. Mixed signed and U64 comparisons preserve both integer ranges.

  • Search arguments execute in their declared types, including explicit casts.
    Supplied fuzzy edit limits and rrf rank constants now refuse null and
    values outside their U32 API range; rrf also requires a positive value.
    Defaults apply only when the optional argument is absent. See the
    search argument ranges.

  • The write_max_bytes session setting no longer has a fixed maximum: the
    former 33554432 ceiling is removed and any value of at least 1 is
    accepted, with the default unchanged at 32 MiB. A value raised above the
    default is held in memory as one typed batch at an overwrite load's commit;
    append and merge keep their 8,192-row chunk bound, and the Blob put limit
    stays capped at 32 MiB.

Fixes

  • A bm25() score no longer depends on the query's filters when rows were
    written after the property's full-text index was built, or when the index
    cannot confirm that it covers every row: such a scan now applies its filter
    after scoring. See the explain
    guide
    .
  • On a local graph, cleanup now finishes a table whose previous run stopped after deleting a table version's unused index files and before deleting the version itself. Before, every later run failed for that table on the missing index directory and deleted nothing; it now counts the directory as already removed and deletes the version. See the maintenance guide.
  • Graph-client setup uses one captured operator configuration, so edits during server discovery cannot redirect the client or change its configured credential owner. Repeated configuration warnings during that setup are reduced; token lookup precedence is unchanged. See server targeting.
  • Cluster reports, stored-query inspection, policy tools and graph listing now return ordinary output errors instead of panicking on a broken pipe. Direct apply preserves the original deployment identity and retained lock when diagnostic or receipt delivery fails, allowing its one attempt to finish without replay; served apply refuses submission if its deployment ID cannot be delivered. See deployment recovery.
  • The CLI matches a server's token on where a request is sent, not on the
    address as written. A request carries the token only when its scheme, host
    and port (or its Unix socket) match the server's url and its path lies
    under that url after . and .. segments resolve. Before, an address
    such as https://host/tenant-a/../tenant-b, or a socket path ending in
    ../other.sock, could carry a declared server's token to a different
    path prefix or socket. A --graph value for a served graph must now be
    one path segment of ASCII letters, digits, - or _; any other value is
    refused before a request is sent. Two servers: names that spell the
    same OMNIGRAPH_TOKEN_<NAME> variable, such as a-b and a_b, are now
    refused when the operator config loads, since one token would bind both.
    See server credentials.
  • CLI completion preserves delivered refusal exit codes and does not append a second JSON response after a final flush failure; served deployment errors retain the original refusal when recovery hints cannot be written. Reported timeouts no longer wait for blocked background lookups at exit, and help/version keep their usual status when output closes. Managed commands attempt recovery-only output on healthy stdout if an accepted operation cannot be reported on stderr; see CLI output and errors.
  • commit publish and commit drop now report conservative write outcomes when a response or result output fails, matching their mutate forms. History commands propagate output failures, and baseline captures hold their output-file lock until the resume cursor is flushed. See failed data-write commands and change baselines.
  • Local account, profile, version, skill-export and embedding reports now return ordinary output errors instead of panicking on a broken pipe; completed credential and file changes remain in place without replay. Invocations share one operator configuration, and ordinary graph clients retain their selected token across registry discovery and the command even if the credentials file changes. See CLI output and errors.
  • Maintenance commands now return output delivery errors without panicking or repeating completed work. Cleanup confirmation and storage-upgrade recovery behavior are preserved. See maintenance failures.
  • query and operator aliases retain the output format and table settings captured for execution, preventing mid-command preference changes and repeated configuration warnings. Captured JSON/JSONL defaults also format structured execution errors; an explicit text format overrides them. See CLI output and errors.
  • Operator aliases and served cluster commands use one operator configuration during client setup, keeping the destination and credential mapping consistent and avoiding repeated setup warnings. See server targeting.
  • Schema, initialization and lint commands now report output delivery failures without panicking. A lost schema-apply result retains reconciliation guidance; output failure does not undo an applied schema or initialized graph. See failed data-write commands.
  • Load and Blob receipt output failures now return through normal CLI error reporting, preserving the write outcome without replaying the operation. See failed data-write commands.
  • commit publish and commit drop accept --as on a direct graph, as the other direct writes do; they previously refused it as if they were reads. commit list, show and changes still refuse --as, and a served publish or drop still takes its actor from the bearer token. A published commit keeps the actor and timestamp of the write that created it. See unpublished commits.
  • A served mutation, load, Blob write or merge can keep serving after a staging
    failure that is proven unpublished; uncertain publication, mutable control
    writes and unknown paths still fail closed. Lost acknowledgements for
    supported Lance 11 fresh-file and create-only manifest writes settle the
    physical storage scope, while retaining transaction files until cleanup
    from a replacement scope satisfies its usual safety checks. See
    shutdown and writer ownership.
  • Deployments: in_progress remains true until the server releases deployment admission, including pending result delivery. Observing in_progress: false confirms that deployment has released its admission.

  • omnigraph embed now embeds a record's @embed source value exactly as
    stored, which is how a text nearest($v, $q) query embeds $q. It used to
    embed a type: <Type> line and a <field>: <value> line instead, so a
    record whose source equaled the query text did not rank at distance zero:
    under the mock provider the two vectors were unrelated, and under a real
    model they were skewed. A record without source text now gets no vector,
    where it used to get one embedded from its type name alone. See
    Embeddings.

  • Full-text functions now match with the index's analyzer (lowercasing and stemming) as soon as rows are written: after a type's first rows, an overwrite load, a newly declared full-text @index, or a newly added full-text property. Before, until omnigraph optimize built the index they matched case-sensitively and without stemming, so search($d.body, "deep") missed "Deep Learning". See the search guide.
  • A historical query no longer reads a dropped property's values through a
    property later re-added with the same name. At a commit that stores a property
    under another lifetime or another name, or not at all, the query is refused
    with a request error naming the property, where before it returned the dropped
    values or failed with an internal error. Commits that read table data written
    before v0.10, which records no property identity, are refused the same way
    unless that data is still current. See historical reads.
  • Return-clause integer sum now accumulates exactly in 128 bits and rounds the total once to F64, preserving cancellation above 2^53. Explain records aggregate types and accumulator choices; regenerate saved version 1 bound plans. See the query guide and explain guide.
  • Authorization: explain load csv over HTTP or MCP requires change permission on its target branch before probing source metadata. Read-only callers cannot inspect external source existence or size. Explaining a load still reads no payload bytes and publishes nothing.

  • CSV loads: Overwrite validation retains fewer duplicate key structures and releases phase-local memory before staging. Optional read caches use the remaining memory allowance and only memoize immutable objects beneath accepted dataset roots. Endpoint validation now costs probes and scans using the consulted table's row count and index coverage.

  • Managed login with --organization now selects the requested organization from
    a fresh WorkOS device session before saving credentials. Existing organization
    sessions remain separate, and ordinary renewal cannot change their identity.

  • Managed CLI login no longer counts OS-keychain consent against its 35-second
    network deadline. Cached-session collision checks still finish before
    organization selection; credentials are saved only after verification succeeds.
    See managed login.

  • branch merge now selects its base as the newest commit both branches descend from. It previously selected the common ancestor closest to both heads by hop count, so a merge commit's second parent could lead it to an older commit and a delete or update made on the branch after it forked could be dropped or reported as a conflict. When two common ancestors are each not an ancestor of the other, the one nearest the two heads by commit count wins, then the higher generation, then the smaller commit id. See merge.
  • Reject overflowing decimal float query literals during type checking with a stable T3 diagnostic.

  • A query shape the planner refuses by design, a nearest() or bm25()
    ranking on a binding a traversal reaches, is a bad request with the planner
    code P001, the refused expression and a fix that answers the query:
    declare that binding first in match. An rrf() whose arms rank two
    bindings one traversal connects is refused as P005 without a fix, since no
    declaration order serves both arms. See the diagnostics guide.

  • A read that projects a wide column no longer fails with resource limit exceeded for query_memory_bytes once the type's projected columns exceed the
    150 MiB query pool, even when it returns one row: every unranked node scan now
    streams bounded batches instead of holding the whole type, so an unordered
    limit stops reading after its first batches and a top-k holds only its kept
    rows. Under a limit over a type with more than four rows per kept row, the
    columns only the output reads are fetched by row address for the kept rows
    alone; explain shows a HydrateColumns node and the
    late_materialization pass. See execution.
  • @range compares values with their bounds exactly. Both sides used to be
    rounded to a double, so an I64 value above 2^53 could pass a maximum it
    exceeds by one, and a U64 value above the largest I64 could pass a
    maximum at that value. A decimal bound on an integer property, and an
    integer bound on a float property, are compared without rounding as well.
    @range on a list property now bounds each element; such a declaration
    used to check nothing. See constraints.
  • A nearest(), bm25() or rrf() order on a binding a traversal reaches
    ranks that binding whichever binding match declares first, and whether or
    not it is declared, instead of being refused (P001) or depending on
    declaration order. See the search guide.
  • Update rustls to 0.23.46 to address four TLS security advisories, and remove
    the unused legacy AWS HTTPS dependencies and their obsolete advisory exemptions.

  • schema plan and schema apply now drop a property that carries @index, @unique, @range or @check, together with every constraint that names only dropped properties, and the same commit removes the property's index. Before, such a drop was refused, so an indexed property could never be removed. Removing a constraint from a property that stays, any @key change, and a drop that would remove a constraint that also names a remaining field are still refused; see the schema guide.

  • A --server value or configured server url: whose scheme is not http,
    https or unix now fails as an invalid server address. It was resolved as
    graph storage and failed with an unrelated storage error such as
    unsupported storage URI scheme.

  • Server logs no longer carry engine error text outside the Blob routes. An
    internal failure on a change route logs error_kind="change_route_internal",
    and an export or change-baseline response that fails after its 200 headers
    logs error_kind="served_stream_failed", each with the error's class
    (error_variant, storage_kind, manifest_kind) instead of its message,
    which can hold object URIs or credentials. A stored-query invocation logs
    the graph's ID instead of its storage root, a graph that fails to open at
    startup logs its root without userinfo, query or fragment, and a refused
    inline embedding api_key is no longer echoed. Responses are unchanged. See
    HTTP errors.

  • Rows that tie on every order key are now ordered by the identities of the
    bindings the query declares before those of anonymous traversal endpoints,
    so a limit cuts them as the declared bindings' order says. See the
    explain guide.
  • Projected parameters retain their declared numeric width and list element type,
    including nulls and empty results. Numeric parameter bounds are checked even
    when a declaration is unused. Mixed integer/float list literals consistently
    have floating-point elements regardless of their order. Saved bound plans now
    carry expression leaf types and use format version 4.

  • Mutation execution uses the node or edge target retained by the compiler.
    Every declared parameter is completed and validated before any statement
    runs, including unused parameters and mutations matching no rows. Missing
    required parameters are refused; omitted nullable parameters from Rust
    callers bind to null. Expected-head checks keep their existing precedence,
    and now() keeps one value across retries.

Performance

  • A read on a warm graph handle checks for new commits by asking for its
    __manifest version and the next one by name instead of listing the version
    directory. On S3-compatible storage that listing returned up to 1,000 keys
    on every read once a branch passed 1,000 commits; the check is now two small
    HEAD requests sent together while nothing changed. See the
    catalog freshness probe.
  • Fewer, larger change pages from the CLI. When commit changes,
    changes poll, diff or branch diff follows every page itself, it now
    asks for 8,192 changes per page instead of the 1,000 the HTTP routes
    default to. Every page restarts its comparison after the last change the
    previous page returned, so fewer, larger pages cost fewer requests and
    less time; the output is unchanged. --limit still sets the size, and a
    single --page-token fetch still defaults to 1,000. See
    changes and change feeds.
  • A correlated block (not { ... }, count { ... }, and the block aggregates)
    that reaches the outer row only through one binding's identity and binds one
    of its own nodes by a key or unique equality now runs once from that node,
    when its row estimate is lower, instead of expanding every outer row's
    binding. Explain reports the choice as the AntiJoin row's strategy. See
    the query guide.
  • Export and the change-feed baseline read the managed Blob values of each
    batch of rows with one planned read per Blob column instead of one read per
    row, and change-feed images and entity reads use the same reader for their
    row. Memory stays bounded by one row's values plus, per Blob column, an
    8 MiB read buffer or one larger value. See
    Blob maintenance and export.
  • A load csv overwrite into an edge type whose endpoint node types carry a
    single integer @key (I32, I64 or U32) now checks every edge's __src
    and __dst against an integer key set built once per endpoint table, read
    straight from the held batches, instead of copying each edge's id and
    endpoints into strings and probing string sets row by row. Which edge is
    refused, and with which message, is unchanged; endpoint types keyed by text
    or U64 keep the previous check. The planner now counts the key list a
    probe builds, one entry per input row, so an endpoint check whose node
    table has no usable __id index plans scan (one read of the id column)
    instead of a probe with one literal per edge endpoint; explain shows the
    access and both costs. A usable index with partial or unknown coverage is
    costed as a full one, so a small key list keeps its filtered probe and a
    large one scans. Integer sets, their build buffers and a probe's key list
    are admitted against query_memory_bytes; oversized hash buckets use
    bounded binary searches.

  • A load statement now shares its committed-state reads: validation opens one
    statement-scoped Lance session with held table handles and a byte-range memo,
    so identical metadata, index and data reads are fetched once per statement
    instead of once per check. The reuse buffers are admitted against
    query_memory_bytes, which now also bounds this load-statement state; an
    allowance that cannot admit them keeps the previous uncached reads. See the
    settings guide.

  • Merges into independent target branches on one handle no longer queue
    behind each other. A merge that misses the handle's single-entry authority
    cache now reopens that branch's coordinator without holding the cache's
    lock, so concurrent merges into different targets overlap; merges into the
    same target still serialize.

  • Automatic traversals price missing or incomplete edge indexes during planning. Explain reports index facts at the pinned dataset version; older saved plans retain their coverage checks. See the explain guide.

Root scans now record and execute their planned scalar-index access. Explain and GQT expose probes and residuals. Single String key equality can use the identity BTREE while retaining its original predicate; older saved plans retain their index defaults.

  • Adding a nullable property, renaming a property and dropping a property no
    longer rewrite the table. Schema apply changes only the table's metadata, so
    its memory and I/O no longer grow with the rows and Blob values the table
    stores, only with its metadata (fragments, columns and indexes): a schema
    change on a large Blob table, which previously held every managed Blob value
    of the table in memory and could exhaust a server running the deployment,
    now reads no row and no Blob value. Existing indexes keep covering their rows
    instead of waiting for the next optimize, and a stored external Blob
    reference to a byte range, which schema apply previously refused, is kept as
    stored. See schema changes.

Removals

  • The embedded Rust Omnigraph::diff_between and Omnigraph::diff_commits
    and their table-shaped ChangeSet, EntityChange, ChangeStats,
    ChangeFilter and ChangeOp types are removed. Use Omnigraph::diff_page,
    which compares any two branches or commits page by page in the
    commit changes change shape with a ChangeFeedScope filter. Its updates
    compare row images, so a row rewritten with equal values is no longer
    reported, and a pair across a dropped and re-added type refuses with
    ChangeSchemaBoundary instead of reporting deletes and inserts. See
    changes, diffs and change feeds.