Skip to content

Latest commit

 

History

History
453 lines (362 loc) · 26.8 KB

CLAUDE.md

File metadata and controls

453 lines (362 loc) · 26.8 KB

VGI Extension Development

DuckDB extension implementing the VGI protocol for remote function execution. Workers expose table, scalar, aggregate, table-in-out and COPY functions to DuckDB over Apache Arrow IPC (subprocess, HTTP, AF_UNIX, launcher, container, GitHub-release, database-package, Iroh, in-browser SAB).

Reference implementations:

  • vgi: /Users/rusty/Development/vgi-python (see docs/* for protocol documentation)
  • vgi_rpc: /Users/rusty/Development/vgi-rpc-python (see docs/* for RPC protocol)

Feature-level documentation lives in docs/ — see Feature reference at the end of this file.

Current development baseline

~/Development/vgi on v2.0 is the primary DuckDB 2.0/nanoarrow checkout. The vgi-nano migration is incorporated here. The duckdb submodule pins Haybarn's 2.0 engine at 81e301d620bf; extension_config.cmake pins its matching HTTPFS fork. Use the committed submodule revision, not git submodule update --remote.

The wire contract is vgi.v3 / 3.3.0 (FunctionInfo.visibility, see docs/function_visibility.md; write-path changes: no catalog_table_scan_function_get, catalog_table_create returns created, write options carry only result_mode, see docs/protocol_routing.md; 3.2 added filtered scan planning, see docs/multi_branch.md). Workers need matching SDK releases; older vgi.v2 and vgi.v3 / 3.0.x–3.2.x workers are incompatible. See docs/protocol-3.3-sdk-releases.json (3.2: docs/protocol-3.2-sdk-releases.json) for the coordinated releases and docs/native-dependencies.md for dependency details.

The Clang Linux ARM64 build and configured suites pass. The latest dependency build, unit and Python/Go transport evidence is in docs/duckdb-2.0-dependency-qualification.json; earlier full language/HTTP matrices have their own artifact hashes. These results do not establish cross-platform release readiness. Automatic whole-query pushdown, nested schemas and broader 2.0 type/grammar coverage remain open in docs/duckdb-2.0-plan.md. Native changes remain on v2.0.

The same source also builds against upstream DuckDB v2.0.0 (scripts/use_duckdb_engine.sh duckdb). Gate engine-specific code on the VGI_ENGINE_HAS_* macros in src/include/vgi_engine_compat.hpp, never on HAYBARN directly. Tests that depend on a feature use require-env VGI_ENGINE_<FEATURE> 1 (or require-env-not VGI_ENGINE_<FEATURE>). The Makefile exports these for Haybarn trees. Direct unittest / run_tests.py runs must load them from make -s engine_test_env. Gate only the cases that need the feature: split them into a sibling file (*_named_args.test) and keep the rest ungated. Lanes that pass --allow-skip take the gating reasons from VGI_ENGINE_EXPECTED_SKIPS. See docs/upstream-duckdb-build.md.

Build

Edit locally; build and test on the Linux ARM64 build host (EC2), never the local Mac. Its address changes whenever the instance restarts, so it is not recorded here: if you don't have it, or ssh times out, ask the user for the current address rather than building locally. Work in a v2.0 checkout on that host with an existing Clang build and ccache. Don't disturb other users' checkouts or the 1.5 builds; if a checkout you borrow is in use, make your own. Restore borrowed checkouts when done. Synchronize changed content with fresh timestamps and record revisions with test evidence.

Use Clang for native 2.0 builds. Do not add a GCC workaround for the diagnosed ARM HUGEINT compiler bug. Reuse the existing Clang build/cache; use the host's full parallelism (CMAKE_BUILD_PARALLEL_LEVEL=$(nproc)) for builds.

The Makefile auto-detects VCPKG_TOOLCHAIN_PATH from vcpkg/ in the project tree. Set USE_MERGED_VCPKG_MANIFEST=1 — the extension is built from multiple modules.

CC=clang CXX=clang++ USE_MERGED_VCPKG_MANIFEST=1 GEN=ninja make debug
CC=clang CXX=clang++ USE_MERGED_VCPKG_MANIFEST=1 GEN=ninja make release

No permission needed to run either build target.

nanoarrow and FlatCC

vcpkg_overlay_ports/ supplies checksum-pinned Query-farm/arrow-nanoarrow and upstream FlatCC. CMake links nanoarrow::nanoarrow_ipc_static and its transitive dependencies. Keep implementation sources out of VGI; vgi-python uses PyArrow.

FlatCC is nanoarrow's C runtime for reading, validating and writing Arrow IPC's FlatBuffers metadata, used with every worker language. Its runtime/verifier are unmodified; install-targets.patch only exports/installs CMake targets. The former Go workaround is removed. vgi-go 0.38.1 selects the corrected Go writer; custom Go workers must copy the documented FlatBuffers replace into their own top-level go.mod and rebuild, because Go does not inherit dependency replacements. Keep the native [vgi-ipc-validation] regression strict.

make wasm_threads selects the separate wasm32-emscripten-threads vcpkg triplet so dependencies also receive -pthread. Direct CMake/custom-triplet builds must provide matching flags. Exact pins and build details: docs/native-dependencies.md.

Test

Debug-mode tests are slow: run the suite against the release build first, then re-run the failures on the debug build to isolate them.

Always tee test output and analyze the log — otherwise the tests get run twice.

set -o pipefail
# Default regression run: whole suite, release build, pooled launcher transport
make test_launcher 2>&1 | tee /tmp/vgi-test.log
grep -A 20 "FAILED" /tmp/vgi-test.log

# Debug build, to isolate a failure the release run surfaced
make test_launcher_debug 2>&1 | tee /tmp/vgi-test-debug.log

make test_launcher serves worker connections from a warm launcher instead of a fresh Python interpreter each time — same coverage, a fraction of the wall clock. make test_spawn cold-starts a worker per connection; use it only when testing the spawn path itself. make test / make test_debug also run the non-integration tests.

VGI_TEST_WORKER selects the worker; it defaults to uv run --project ~/Development/vgi-python vgi-fixture-worker in the Makefile. When invoking unittest directly, set it explicitly: otherwise worker-gated tests skip. scripts/run_tests.py reports executed/skipped counts separately, parsing both stdout and stderr; a zero exit code alone does not prove coverage.

VGI_DATABASE_PACKAGE_WORKER is the worker command that database_worker/package.test packages as a database:// executable. It defaults to VGI_TEST_WORKER (minus launch:); lanes whose VGI_TEST_WORKER is a location (http://, unix://) must set it — the run_http_integration.sh / run_unix_integration.sh scripts default it to the Python fixture worker. Unset on such a lane, the packaged fixture fails with a message naming the variable.

Running specific tests

VGI_TEST_WORKER="uv run --project ~/Development/vgi-python vgi-fixture-worker" \
    ./build/release/test/unittest --test-config test/configs/no_error_skip.json \
    "test/sql/integration/scalar/double.test"   # or a glob: ".../scalar/*"

./test/run_http_integration.sh "test/sql/integration/scalar/double.test"      # over HTTP

For debugging, write standalone .sql files in /tmp/ and run them with ./build/debug/haybarn -f /tmp/test.sql. Each test file should complete in <10 seconds.

Cross-SDK conformance (make test_languages)

The .test files ARE the cross-SDK conformance suite. Each carries require-env VGI_TEST_WORKER, so the same files run unchanged against the Python, Rust, Go, TypeScript, Java and C# workers.

make test_languages          # six SDK targets plus native references; keeps going on failure
make test_rust               # one leg (also test_python/test_go/test_typescript/test_java/test_csharp)

The C++ SDK lane runs separately; both TypeScript ArrowJS and Flechette backends also need qualification when claiming full language/backend coverage. Keep the existing execution floors and skip allowlists; record genuine passes separately from expected skips. See docs/duckdb-2.0-native-qualification.json and docs/duckdb-2.0-http-qualification.json for matrix commands and evidence.

Run it after touching anything on the wire. Adding cases to the Python suite does not substitute: a bug in one SDK's serializer is invisible to tests that only run against Python. The first full run found 13 real bugs across four SDKs. Run the matrix on the build host; the native CI does not run it.

Other transports and suites

Target What it runs
make test_http / _debug Integration suite over HTTP (test/run_http_integration.sh); a server per test file by default. VGI_HTTP_SERVER_PER_TEST=0 selects one shared server with a per-run log (VGI_HTTP_SERVER_LOG overrides its path).
make test_http_no_compression HTTP against a server advertising an empty VGI-Supported-Encodings (speaks no compression; an absent header means a pre-update server that still speaks zstd)
make test_http_demo_storage HTTP against a server that externalizes every response to its demo object store; the only lane fetching externalized results from inside VgiTransaction::Start (duckdb#22258 secret-lookup deadlock).
make test_launcher_external_storage Launcher suite against the fixture worker externalizing every result over the byte transport (test/support/external_storage_worker.py)
make test_unix, make test_shm AF_UNIX transport; shared-memory side channel
make test_all / _debug spawn, shm, unix, http, plus the bearer / versioned-tables / attach-options / no-compression HTTP variants
make test_docker Container suite against the vgi-sklearn image; skips cleanly without a runtime. VGI_DOCKER_IMAGE, CONTAINER_RUNTIME override. See docs/container-transport.md
make test_companion, make test_iceberg Lakehouse federation; iceberg_scan cold-tier branch (skips in the bare suite)
make test_database_workers Builds real PyInstaller / Bun / Rust workers and runs them via database://. Needs sibling vgi-python, vgi-open-meteo, vgi-rust and uv/bun/cargo/tar. See docs/database-worker-transport.md

HTTP test coverage pitfalls

A skipped test is not a pass. scripts/run_tests.py distinguishes skips and automatically uses test/configs/no_error_skip.json to prevent DuckDB's broad "HTTP" / "Unable to connect" error skips from hiding failures. Direct unittest invocations must select that config too. Preserve the lane's skip allowlist and execution floor.

Use the existing make test_http target. Before a full run, check that the selected Python/fixture environment has the vgi-rpc[http] extra and run ./test/run_http_integration.sh "test/sql/integration/scalar/double.test" as a preflight. Put the intended Python environment on PATH; server startup failures do not qualify the native adapter. For published RPC qualification, use make test_http VGI_RPC_PYTHON_DIR= to disable the Makefile's sibling RPC checkout override. Use VGI_RUN_TESTS_JOBS for file parallelism (the latest build-host HTTP run used 24). HTTP servers run from the repository root because COPY paths resolve against their cwd. Versioned/attach/auth variants have separate targets; the default HTTP target alone does not cover every variant.

There are no known HTTP-only limitations. Before recording one, measure it against at least two SDKs and date it. Every single-SDK failure investigated so far was a bug in that SDK, and stale "known limitation" notes have hidden real defects.

C++ unit tests (vgi_unit_tests)

A Catch binary (test/cpp/), configured only when BUILD_VGI_UNIT_TESTS is set at configure time. It links two Rust staticlibs CMake does not build — test/support/sabffi (vgi-rpc) and test/support/sabtable (vgi) — so build them first or make release fails to link:

make unit_test_rust_libs
CC=clang CXX=clang++ BUILD_VGI_UNIT_TESTS=1 USE_MERGED_VCPKG_MANIFEST=1 GEN=ninja make release
./build/release/extension/vgi/vgi_unit_tests 2>&1 | tee /tmp/vgi-unit.log
./build/release/extension/vgi/vgi_unit_tests "[sab-conn]"   # one tag

Both crates build --locked from crates.io against committed lockfiles — never a path or [patch.crates-io] to a sibling checkout (keep such a patch uncommitted for local trials). They must resolve one vgi-rpc version; scripts/check_rust_fixture_locks.sh (run by make unit_test_rust_libs) fails on drift, so bumping sabtable's vgi across a vgi-rpc move means bumping sabffi's vgi-rpc in the same change.

For an unpublished protocol candidate, build separate copies of both fixtures against the exact candidate SDK revision, with one matching published vgi-rpc version and Arrow major. Keep the repository manifests, locks and registry-built libraries intact; record the copied manifests/locks, SDK revision and library hashes, then build the copies with --locked. Select their outputs explicitly:

cmake -S duckdb -B build/release -DBUILD_VGI_UNIT_TESTS=ON \
  -DSABFFI_LIB=/absolute/candidate/target/release/libsabffi.a \
  -DSABTABLE_LIB=/absolute/candidate/target/release/libsabtable.a
cmake --build build/release --target vgi_unit_tests
./build/release/extension/vgi/vgi_unit_tests

These cache paths affect only vgi_unit_tests. The default fixtures use the registry VGI 0.51 SDK (vgi.v3 / 3.3.0), vgi-rpc 0.32.4 and Arrow 59, pinned by both lockfiles (Arrow 59 matches the Rust SDK, which tracks DataFusion's Arrow). The lock guard also checks the matching vgi-protocol package and Arrow versions. Before a SAB worker thread starts, its linked SDK identity must match the native generated protocol name/version. Candidate-library results prove candidate interoperability, not a published-dependency release. Unset both cache entries (cmake -U SABFFI_LIB -U SABTABLE_LIB ...) and rerun the full unit suite to qualify the registry defaults.

The [flock] parity cases pass as skipped unless python3 can import filelock; put e.g. vgi-python's .venv/bin first on PATH.

CI

  • .github/workflows/MainDistributionPipeline.yml — header-hygiene (scripts/header_reach.py --check) and the reusable distribution build. It does not run the integration suite: the reusable workflow has no pre-test command hook and its Linux leg tests in a fresh container, so every integration test skips there.
  • .github/workflows/integration.yml — the integration suite (launcher transport). It runs scripts/ci_install_fixtures.sh (VGI_INSTALL_FIXTURES=1), which clones the public vgi-python repo, installs the dev-only fixture workers, and verifies the worker runs. Fixtures follow vgi-python's default branch (VGI_FIXTURES_REF, overridable via the fixtures_ref workflow_dispatch input), so a protocol bump must land on both sides.
  • Not in CI: the cross-SDK matrix (make test_languages).

The distribution workflow still selects haybarn-v1.5.5-rc1 and v1.5.5 images. It does not qualify DuckDB 2.0 distribution; the 2.0 Clang evidence above is from the build-host lane. Updating the distribution/platform matrix remains release work.

Debug Environment Variables

Variable Effect
VGI_STDERR_LOG=1 stderr debug logging (VGI_LOG, VGI_STDERR_DEBUG, catalog instrumentation events)
VGI_STDERR_LOG_PRETTY=1 Pretty-print stderr logs (with VGI_STDERR_LOG=1)
VGI_IPC_DEBUG=1 Low-level Arrow IPC stream debug output
VGI_WORKER_STDERR_PASSTHROUGH=1 Pass worker stderr through to the terminal
VGI_WORKER_DEBUG=1 Passthrough + sets VGI_IPC_DEBUG=1 in the worker
VGI_RPC_SHM_SIZE_BYTES=N Enable the shared-memory side channel for subprocess workers (see docs/shm_transport.md)
VGI_RPC_SHM_DEBUG=1 Log each resolved / fallback shm batch
VGI_PROFILE=1 ScopedTimer aggregate summary to stderr at exit, incl. every catalog RPC

Catalog RPC / cache instrumentation (catalog.rpc, catalog.entry_cache, …) is queryable via SET enable_logging=true; SET enable_log_types='VGI'; then duckdb_logs. See docs/catalog_profiling.md.

Generated Code (src/generated/)

Produced by generators in vgi-python from the VgiProtocol / VgiSecretProtocol classes — the single source of truth for the wire shape, protocol names, versions and vgi_rpc.* metadata keys. Never edit by hand. Regenerate with:

uv run --project ~/Development/vgi-python python \
    ~/Development/vgi-python/scripts/regen_generated.py

Use that script, not python -m vgi.codegen.X > dest: the shell truncates the destination before the generator runs, so a failing generator silently destroys the file. --check reports drift. vgi-python's tests/test_generated_cpp_*.py fail CI if checked-in headers diverge. VGI_EXTENSION_ROOT=<checkout> points the script at a checkout other than ~/Development/vgi.

Protocol records are typed structs, not hand-parsed batches. vgi_protocol_records.hpp has one struct per record and one enum class per protocol enum (over vgi_arrow.hpp types only); vgi_protocol_records.cpp has ToBatch(record) / generated::Decode<T>(batch, row, worker) plus AllMethodSchemas(), the per-method schema table the schema registry is built from. The codecs call the runtime in vgi_wire_codec.{hpp,cpp} — the only code that touches arrays for protocol records. Generated with vgi-python's nanoarrow backend (regen_generated.py does this; vgi-c++/vgi-sqlite keep the Arrow C++ backend). Decoding is by column name: a missing nullable column is absent; a missing or null required column, a wrongly typed column, an unknown enum value or a repeated map key is a protocol error, as is a null in a non-nullable list/map or a null item in a list whose element is not optional. Enums accept only the canonical member name. Do not add leniency for an SDK that sends something else — fix the SDK. Use DecodeIpcRecord<T> / SerializeRecord for records carried as IPC blobs and UnwrapResultEnvelope for a unary {result: binary} response — never read a protocol column by hand. Deliberately hand-written: the zero-copy plan-page and catalog_contents decoders, and the attach-ticket / Identity / Reflection protocols.

Requests are routed on (protocol, method): vgi_rpc.protocol is required on raw transports and projected into the URL ({base}/{protocol}/{method}) over HTTP. Reserved methods (__transport_options__, __upload_url__) carry no protocol key. See docs/protocol_routing.md.

Coding Conventions

Arrow data: nanoarrow, not Arrow C++

The extension does not link Arrow C++. Batches, schemas and bytes are the types in src/include/vgi_arrow.hpp (VgiBatch/VgiBatchPtr, VgiSchema, VgiColumn views, VgiBuffer, VgiMetadata, schema/array builders, TakeRows/ConcatBatches), built on the Arrow C data interface and pinned vcpkg nanoarrow/FlatCC packages (see docs/native-dependencies.md). IPC streams are src/include/vgi_ipc.hpp (VgiIpcReader/VgiIpcWriter, VgiInputStream/ VgiOutputStream; errors throw). Do not reintroduce arrow:: — vcpkg.json no longer has it. Worker batches reach DuckDB zero-copy through VgiBatch::ExportTo(ArrowArrayWrapper&); DuckDB chunks become batches straight from ArrowAppender (DataChunkToArrow).

Arrow-to-DuckDB type conversion

Always use ArrowSchemaToDuckDBTypes() (vgi_arrow_utils.hpp). Never hand-write a switch over Arrow type ids — it misses complex types (struct, list, map, timestamp…) and silently falls back to VARCHAR.

Header hygiene

No project header may include nanoarrow/, flatcc/ or arrow/ headers (nanoarrow.h carries thousands of lines of inline functions). Headers use the vgi_arrow.hpp / vgi_ipc.hpp types, which need only DuckDB's C data interface structs; include nanoarrow/nanoarrow.h in the .cpp that calls nanoarrow directly. scripts/header_reach.py --check (CI) enforces this for every header in src/include.

vgi_catalog_api.hpp is a back-compat umbrella — include the most specific of vgi_attach_parameters.hpp ⊂ vgi_catalog_metadata.hpp ⊂ vgi_catalog_rpc.hpp (only for .cpp files that issue catalog RPCs).

python3 scripts/header_reach.py prints per-header TU reach; --check enforces the denylist and runs in CI.

Transports and location policy

When adding a transport or changing LOCATION dispatch, update ClassifyLocationForPolicy (src/vgi_location_policy.cpp) to match: it must classify a string as what dispatch will really do with it, and its fall-through is subprocess (a /bin/sh -c). See docs/location_policy.md.

Worker contracts the client does not check

Some obligations belong to the worker and are deliberately not policed client-side: split disjointness across paginated enumeration (duplicates return duplicate rows), keeping SINGLE_VALUE splits single-valued, split replayability, and per-unit purity of any exchange function that advertises vgi.cache.* (a stateful map that advertises cacheability serves stale rows on a hit). Revisit only if a cheap, uniform check becomes possible (e.g. a stable split id on the wire).

Architecture

Function protocol

vgi_rpc over Arrow IPC streams:

  • Table functions — producer mode: client sends 0-row tick batches, worker produces output.
  • Scalar functions — exchange mode: input batches in, 1:1 output batches back.
  • Table-in-out — exchange mode for INPUT, producer mode for FINALIZE. Streaming table-in-out fans out one worker per substream; blended (RowTransformFunction) functions take their per-row input from positional args; correlated LATERAL is batched into one exchange per chunk by PhysicalVgiLateralBatch.
  • Buffered table functions (TableBufferingFunction) — Sink+Source PhysicalVgiTableBufferingFunction: table_buffering_process per thread, _combine after Sink, _finalize drains per finalize-state id. Sink→Source state must live in cross-process storage keyed by execution_id (BoundStorage) — the Source worker is generally a different process.

Details for all of the table-in-out shapes: docs/table_in_out.md.

Catalog integration

Workers expose functions via ATTACH 'catalog_name' AS name (TYPE vgi, LOCATION 'worker_path'); src/storage/* maps worker metadata onto DuckDB's catalog interface. ATTACH is the only way in — the standalone vgi_table_function(...) was removed (faf6496) and is not coming back. vgi_table_scan is a synthetic internal entry for re-planning bound catalog tables, not a user-facing replacement.

Worker connection pool

Subprocess workers are pooled (vgi_worker_pool_max, vgi_worker_pool_idle_limit_seconds; per-catalog pool, pool_max, pool_timeout). AcquireAndBindConnection() retries with a fresh worker if a pooled one died (EPIPE); SIGPIPE is ignored via sigaction(). Pool diagnostics (vgi_worker_pool*()) cover only the subprocess pool — launch: / unix:// workers are shared at the OS level and return no rows.

Private subprocesses that have advertised SHM are excluded from generic process-pool reuse: later catalog/bind readers lack a SHM resolver for the worker's retained session. Those executions start a fresh process; within-execution SHM and retained batch leases remain supported. Preserve this rule when changing pool/connection cleanup.

Logging

  1. VGI_LOG(context, "event", {{"key", "val"}}) — DuckDB log manager.
  2. VGI_STDERR_DEBUG(...) — no context needed, enabled by VGI_STDERR_LOG=1.
  3. In-band worker logs — 0-row batches with vgi_rpc.log_level metadata; EXCEPTION throws via ThrowVgiUserException (InvalidInputException, or VgiRpcException with an error kind/code), deliberately not IOException so it is never retried.

Concurrency

  • VgiCatalogSet guards entries with entry_lock_. LoadEntries() runs under load_lock_, not entry_lock_; overrides take entry_lock_ themselves around each CreateEntryLocked() call.
  • VgiWorkerPool uses mutex_ (pool ops) and cleanup_mutex_ (cleanup thread).
  • A FunctionConnection is single-threaded (one per query thread).

Gotchas

  • DuckLake builds its scan from parquet_scan's bind: a catalog-table branch over DuckLake must declare required_extensions=["parquet"], or it segfaults where parquet isn't autoloaded (e.g. the unittest binary). Use the 3-arg GetScanFunction with EntryLookupInfo.
  • COPY formats, global functions and the remote secret provider registered at ATTACH are not unregistered by DETACH (DuckDB has no unload API); anything that outlives DETACH must re-resolve the catalog by alias rather than hold a Catalog&.
  • vgi-python function classes are CamelCased with a Function suffix (projected_data → ProjectedDataFunction).

Feature reference

Topic Doc
DuckDB 2.0 scope and remaining work docs/duckdb-2.0-plan.md
Haybarn vs upstream DuckDB builds (vgi_engine_features()) docs/upstream-duckdb-build.md
Native dependencies and Go producer compatibility docs/native-dependencies.md
Current dependency build/release evidence docs/duckdb-2.0-dependency-qualification.json
Settings, ATTACH options, LOCATION schemes, SQL diagnostic functions docs/reference.md
Structured error fields (errors_as_json, error_subtype, extra_info keys) docs/error_info.md
Source file / header map docs/source_map.md
Table-in-out: parallel fan-out, blended, buffered, batched LATERAL docs/table_in_out.md
Table-function result cache (memory/disk, partition, exchange-mode) docs/result_cache.md, docs/result_cache_compression.md, docs/result_cache_packed_store.md, docs/exchange_dedup_pervalue.md
Worker batch validation (vgi_validate_worker_batches) docs/worker_batch_validation.md
Shared-memory transport docs/shm_transport.md
Protocol routing docs/protocol_routing.md
Catalog profiling docs/catalog_profiling.md
catalog_contents docs/catalog_contents.md
Secret ATTACH options docs/attach_credentials.md
Remote secret provider (Orchard) docs/remote_secret_provider_plan.md, docs/remote_secret_provider_status.md
Companion catalogs (lakehouse federation) docs/companion_catalogs.md
Multi-branch tables docs/multi_branch.md
Function visibility (table_only scan/write functions, protocol 3.3) docs/function_visibility.md
MERGE / INSERT ... ON CONFLICT emulation, CTAS created, write options (protocol 3.3) docs/protocol_routing.md
Cross-SDK writable-table fixture contract (txfix, simple_writable CTAS) docs/writable_tx_fixtures.md
Global functions (system.main) docs/global_functions.md
Custom COPY ... FROM / TO docs/copy_from.md, docs/copy_to.md
Telemetry docs/telemetry.md
Location policy (vgi_allowed_transports) docs/location_policy.md
Transports: container, GitHub release, database package, launcher, Iroh, WASM/SAB docs/container-transport.md, docs/github-transport.md, docs/database-worker-transport.md, docs/launcher-*.md, docs/native-iroh-transport.md, docs/wasm-worker-transport.md, docs/sab_transport_abi.md