The bug

commit_handler_from_url in rust/lance-table/src/io/commit.rs picks a commit handler by URL scheme (lines 745–810):

match url.scheme() {
    "file" | "file-object-store" => Ok(local_handler),
    "s3" | "gs" | "az" | "abfss" | "memory" | "oss" | "cos" => {
        Ok(Arc::new(ConditionalPutCommitHandler))
    }
    ...
    _ => Ok(Arc::new(UnsafeCommitHandler)),
}

memory is in the conditional-put list, but the new shared-memory scheme added by this PR is not. It therefore hits the wildcard arm at line 809 and gets UnsafeCommitHandler — which writes the manifest directly to the final path without any compare-and-swap, so concurrent writers cannot detect a conflict.

Why existing code doesn't prevent it

The PR only touches rust/lance-io (the object-store provider layer). Nothing in lance-table was updated. A grep for shared-memory/shared_memory in the repo shows the string appears only in the three files this PR touches; there is no integration in the commit-handler selection. The PR also adds no Dataset-level tests for the new scheme — its tests exercise ObjectStore::from_uri_and_params directly — so the gap is invisible to the test suite.

Impact

The PR description specifically advertises this use case: 'manifest-store + WAL-writer agreement on the same backing bytes'. That coordination requires CommitConflict semantics on the manifest path, which is exactly what UnsafeCommitHandler removes. Result: a user following the PR's stated use case gets silent data loss on concurrent commits, while the analogous memory:// URL behaves correctly.

The underlying backend is the same (shared-memory wraps the same object_store::memory::InMemory, just with a process-global Arc), and InMemory supports conditional puts — that's precisely why memory is in the ConditionalPutCommitHandler arm in the first place. So the existing handler is the correct choice for shared-memory too.

Step-by-step proof

1. Caller invokes Dataset::write(data, "shared-memory://bucket-a/ds", ...) without supplying an explicit commit_handler.
2. The write path (e.g. rust/lance/src/dataset/write.rs) calls commit_handler_from_url("shared-memory://bucket-a/ds", ...).
3. url.scheme() returns "shared-memory".
4. Line 746 (file | file-object-store) does not match.
5. Line 747 (s3 | gs | az | abfss | memory | oss | cos) does not match — shared-memory is not listed.
6. None of the s3+ddb arms match.
7. Control falls through to line 809: _ => Ok(Arc::new(UnsafeCommitHandler)).
8. UnsafeCommitHandler::commit writes the manifest directly to its final path with no conditional-put guard.
9. A second concurrent writer to the same dataset does the same — its manifest write succeeds and overwrites the first writer's manifest. No CommitConflict is ever raised.

Repeating step 1 with memory://bucket-a/ds instead routes through ConditionalPutCommitHandler at line 748 and correctly returns CommitConflict on the racing writer.

Fix

Add "shared-memory" to the existing match arm:

"s3" | "gs" | "az" | "abfss" | "memory" | "shared-memory" | "oss" | "cos" => {
    Ok(Arc::new(ConditionalPutCommitHandler))
}

A Dataset-level concurrent-write test against a shared-memory:// URL would also make this gap visible going forward.