…C layer

Integrate the hosted Tabularium registry (registry.tabularis.dev) alongside
the legacy static registry.json, with version-aware deep-link install.

- Merge new HTTP API catalogue with legacy registry.json (union, API wins
  on id conflict) so old plugins (duckdb, ...) stay visible.
- Semver-aware install classification: install / update / already-installed.
- Tracked asset downloads via the registry redirect endpoint:
  /api/plugins/{slug}/latest for unpinned, /releases/{version} for pinned.
- Host manifest parser migrated to .tabularium (JSON), legacy manifest.json
  read as fallback.

All backwards-compat code lives in plugins/compat.rs and is marked with
`COMPAT(registry-ga):` at every call site, so it can be removed mechanically
once all plugins have migrated to the hosted registry.

Redesign the New Connection flow around a searchable driver catalogue that
merges built-in drivers with registry plugins.

- EngineCard, ConnectionCatalogue (search + paradigm facets + grid),
  DriverVersionPicker, InstallBanner, InstallGate components.
- useConnectionCatalogue hook + connectionCatalogue normalization model.
- Catalogue is step 1 of the New Connection wizard; uninstalled drivers are
  install-gated with inline driver install.

PluginInstallConfirmModal now renders the install action returned by the
preview command: Install, Update (when a newer version exists), or an
already-installed banner for an up-to-date plugin.

- useDeepLinkInstall hook drives the tabularis://install flow.
- PluginsTab consumes the registry base URL per plugin for its registry link.

Add registry/catalogue and deepLink (updateConfirm, alreadyInstalled)
strings across all 7 locales.

…tion

# Conflicts:
#	tests/setup.ts

- NewConnectionModal: remove unused PluginManifest import.
- PluginInstallConfirmModal: key the modal by request in App.tsx so each
  request remounts with fresh state, replacing the synchronous state reset
  inside the effect (react-hooks/set-state-in-effect). Loading state now
  initialises from the keyed mount; the effect only sets state in its async
  callbacks.

…ration

…-ready CI

- scaffold emits .tabularium (was manifest.json); keep id=slug/name=display
  so the host identity/display split is preserved
- add `migrate [path]` to convert legacy manifest.json plugins to .tabularium;
  drops a redundant id (id===name), refuses without a semver version
- `migrate --ci` regenerates release.yml from the registry-ready template
  (BIN_NAME from manifest.executable); without --ci the workflow is left as-is,
  only its manifest.json reference is renamed
- release.yml template: stash artifacts + single release job publishing
  .tabularium as a standalone asset (Tabularium registry resolves the manifest
  from release assets); assets/ dir support; action version bumps
- plugin-api: doc comments reference .tabularium
- bump @tabularis/create-plugin 0.1.1 -> 0.2.0

…tion

# Conflicts:
#	src/components/modals/NewConnectionModal.tsx

…iver support

Surface registry engine/paradigms on manifests so locally-installed (not
yet published) plugin drivers appear in the connection picker instead of
loading invisibly. Add single_database capability to skip the database
tab/field for flat stores (e.g. Meilisearch).

…currency

WIP — review fixes for the hosted Tabularium registry. Not final;
JWS-signed install verification still pending (registry Phase-2 not released).

Frontend:
- i18n the connection catalogue components (ConnectionCatalogue, EngineCard,
  InstallGate, DriverVersionPicker) — were hardcoded English; add
  connectionCatalogue.* keys to all 7 locales + backfill changeDatabase /
  deepLink.updateConfirm / deepLink.alreadyInstalled
- delete dead InstallBanner (+ test); move InstallStatus into InstallGate
- EngineCard: aria-label uses displayName; surface platform-unsupported
  drivers via EngineGroup.platformSupported (badge + dim) instead of a
  click-through dead end
- useConnectionCatalogue: move setLoading out of the synchronous effect body

Backend:
- registry: bound the plugin-detail fan-out with buffered(8) instead of an
  uncapped join_all over up to 200 plugins
- deep_link: parse the slug from the no-`//` tabularis:install/<slug> form
- lib: handle a warm-launch deep link forwarded via argv (single-instance)

Tests updated to the key-echo i18n mock convention.

Still open (not in this commit): JWS install trust model, EngineGroup test
churn, cold-start double-dispatch.

…ration

# Conflicts:
#	src-tauri/Cargo.lock
#	src/App.tsx
#	src/components/modals/NewConnectionModal.tsx
#	src/i18n/locales/de.json
#	src/i18n/locales/en.json
#	src/i18n/locales/es.json
#	src/i18n/locales/fr.json
#	src/i18n/locales/it.json
#	src/i18n/locales/ja.json
#	src/i18n/locales/zh.json
#	tests/setup.ts

The merge with main left `cargo test` uncompilable: the test helper builds
PluginManifest with every field spelled out, and this branch added `engine`
and `paradigms` to the struct. The lib itself built fine, so only the test
profile broke.

During the registry transition the catalogue merges the Tabularium API with
the legacy static registry.json. merge_registries appends legacy-only
plugins and drops the distinction, after which fetch_plugin_registry stamped
`registry_base_url` onto every entry — its guard only checked whether the
configured base was a `.json`, which never holds in the merge case.

A not-yet-migrated plugin (e.g. redis) therefore claimed to be served by the
API, and the frontend linked its card to `<base>/plugins/redis`, which 404s.
Since registryPageUrl wins over the upstream homepage, the real homepage was
never reached.

Stamp the base in resolve_registry instead, where it's still known whether a
plugin came from the API or the legacy file. Legacy entries stay unstamped
and fall back to their homepage on their own.

read_manifest already falls back to the legacy manifest.json, but
has_manifest only looked for .tabularium. Install and list gate on
has_manifest first, so a not-yet-migrated bundle (e.g. redis) was rejected
as "does not contain a .tabularium manifest" — and, once installed, skipped
by list_installed — even though the read path would have loaded it fine.

Make the presence check agree with the read path via compat::has_legacy_
manifest, so both callers are fixed at the shared gate rather than each
symptom. Both disappear together at the cutover.

The Installed tab renders from driver data and showed the amber
update badge (which comes from the registry), but had no way to act on it —
the install button only exists on the catalogue cards. Users saw the problem
and were left without the fix.

Add the update button next to the existing per-plugin actions, gated by
canUpdateToLatest: update_available alone only means a newer version exists,
so the release must also ship a build for this platform and support this app
version. Notably the catalogue degrades to the release-less list item when a
detail fetch fails, where update_available stays true — the releases check
keeps us from offering an update we cannot perform.

Registry 0.13 gates GET /api/plugins on a manifest having resolved at ingest,
so approved is no longer enough to be listed. Detail and latest are not gated:
a plugin can be invisible in the catalogue while its slug still resolves.

The catalogue only ever iterated the listed set, so an installed plugin whose
publisher shipped a release with an unresolvable .tabularium would silently
lose its update path — no badge, no button, no error. Dropping out of the list
is not a deletion.

Re-resolve installed-but-unlisted plugins by slug and fold them back in.
Unknown slugs (locally-installed, legacy-only) are skipped quietly, and when
the API itself is down we return the legacy set as-is rather than firing
lookups that cannot succeed.