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(seedocs/*for protocol documentation) - vgi_rpc:
/Users/rusty/Development/vgi-rpc-python(seedocs/*for RPC protocol)
Feature-level documentation lives in docs/ — see Feature reference at the end of this file.
~/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.
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 releaseNo permission needed to run either build target.
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.
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.logmake 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.
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 HTTPFor 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.
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.
| 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 |
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.
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 tagBoth 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_testsThese 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.
.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 runsscripts/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 thefixtures_refworkflow_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.
| 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.
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.pyUse 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.
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).
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.
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.
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.
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).
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 byPhysicalVgiLateralBatch. - Buffered table functions (
TableBufferingFunction) — Sink+SourcePhysicalVgiTableBufferingFunction:table_buffering_processper thread,_combineafter Sink,_finalizedrains per finalize-state id. Sink→Source state must live in cross-process storage keyed byexecution_id(BoundStorage) — the Source worker is generally a different process.
Details for all of the table-in-out shapes: docs/table_in_out.md.
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.
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.
VGI_LOG(context, "event", {{"key", "val"}})— DuckDB log manager.VGI_STDERR_DEBUG(...)— no context needed, enabled byVGI_STDERR_LOG=1.- In-band worker logs — 0-row batches with
vgi_rpc.log_levelmetadata;EXCEPTIONthrows viaThrowVgiUserException(InvalidInputException, orVgiRpcExceptionwith an error kind/code), deliberately notIOExceptionso it is never retried.
VgiCatalogSetguards entries withentry_lock_.LoadEntries()runs underload_lock_, notentry_lock_; overrides takeentry_lock_themselves around eachCreateEntryLocked()call.VgiWorkerPoolusesmutex_(pool ops) andcleanup_mutex_(cleanup thread).- A
FunctionConnectionis single-threaded (one per query thread).
- DuckLake builds its scan from
parquet_scan's bind: a catalog-table branch over DuckLake must declarerequired_extensions=["parquet"], or it segfaults where parquet isn't autoloaded (e.g. the unittest binary). Use the 3-argGetScanFunctionwithEntryLookupInfo. - 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
Functionsuffix (projected_data→ProjectedDataFunction).
| 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 |