test(obsidian): focus adaptive PostgREST journey

docs/settings.md

@@ -58,7 +58,7 @@ A current Setup URI retains its remote profiles, display names, and separate mai
 
 Step-by-step setup for Self-hosted LiveSync. You can setup Self-hosted LiveSync manually with Minimal setting items.
 
-Completing manual CouchDB, Object Storage, or P2P setup creates the corresponding remote profile without replacing profiles which are already saved. CouchDB and Object Storage setup select the new profile as the main remote. P2P setup selects it for P2P use and, when the wizard is enabling LiveSync, also selects it as the main remote. A descriptive display name is generated and can be changed later.
+Completing manual CouchDB, Object Storage, WebDAV, PostgREST, or P2P setup creates the corresponding remote profile without replacing profiles which are already saved. CouchDB, Object Storage, WebDAV, and PostgREST setup select the new profile as the main remote. P2P setup selects it for P2P use and, when the wizard is enabling LiveSync, also selects it as the main remote. A descriptive display name is generated and can be changed later.
 
 #### Enable LiveSync
 
@@ -171,7 +171,7 @@ Show verbose log. Please enable when you report the logs
 
 ### 1. Connection settings
 
-Self-hosted LiveSync stores multiple remote connection profiles under **Connection settings** → **Saved connections**. Each profile represents a CouchDB database, an Object Storage connection, or a P2P configuration, and several profiles can be kept in one Vault.
+Self-hosted LiveSync stores multiple remote connection profiles under **Connection settings** → **Saved connections**. Each profile represents a CouchDB database, a Journal storage connection, or a P2P configuration, and several profiles can be kept in one Vault.
 
 Each profile has an opaque identifier and a presentation name. The name does not need to be unique and is not used to select the profile. The main remote and the P2P remote are selected independently, so code and settings imports must preserve both selections rather than relying on a special identifier such as `default`.
 
@@ -355,7 +355,31 @@ The dialogue reports required operations and Range support independently. Authen
 
 Onboarding accepts the profile only after the selected policy passes. Adding or editing a profile in Settings also offers **Save without connecting**, which preserves a locally valid but unverified profile.
 
-### 7. CouchDB
+### 7. PostgREST Journal
+
+PostgREST Journal is an experimental, Adaptive-only provider. It uses the packaged PostgREST RPC schema rather than exposing synchronisation tables or acting as a CouchDB replication endpoint.
+
+#### PostgREST connection
+
+Setting key: postgrestActiveConnectionURI
+
+The saved `sls+postgrest` value contains the HTTP or HTTPS endpoint, exposed schema, Vault ID, Vault credential, optional client-safe API key, and internal-API preference. A trusted database administrator provisions the Vault ID and credential by following the SQL package instructions. Do not enter a database credential, Supabase secret key, or `service_role` JWT in a client profile.
+
+Only HTTPS endpoints work on Obsidian Mobile. **Use internal API** routes requests through Obsidian when browser-compatible requests are blocked by CORS.
+
+#### Adaptive format and repository identity
+
+PostgREST always uses `adaptive-v1` with native Chunk rows and does not expose Opaque Journal, object Pack, Catalogue, Delta, or Range-retrieval options. Existing data in another Journal format is not read or migrated. Changing the wire or SQL format requires detection and a remote Rebuild.
+
+Setting key: expectedRepositoryId
+
+The optional expected repository ID pins a trusted Adaptive repository in the same way as other Adaptive Journal providers.
+
+#### Server capability check
+
+The setup dialogue verifies the installed RPC operations, Vault authentication, and exact binary behaviour through the provider-neutral Journal inspection boundary. Onboarding accepts the profile only after this check succeeds. Settings can preserve a locally valid profile without connecting so that an unavailable endpoint can be corrected later.
+
+### 8. CouchDB
 
 These settings are configured within the CouchDB Setup dialogue when adding (`➕`) or editing (`🔧`) a CouchDB connection profile.
 

package.json

@@ -63,6 +63,7 @@
         "test:e2e:obsidian:revision-repair": "tsx test/e2e-obsidian/scripts/revision-repair.ts",
         "test:e2e:obsidian:document-history-nav": "tsx test/e2e-obsidian/scripts/document-history-nav.ts",
         "test:e2e:obsidian:settings-ui": "tsx test/e2e-obsidian/scripts/settings-ui.ts",
+        "test:e2e:obsidian:remote-setup-providers": "tsx test/e2e-obsidian/scripts/remote-setup-providers.ts",
         "test:e2e:obsidian:review-harness": "tsx test/e2e-obsidian/scripts/review-harness.ts",
         "test:e2e:obsidian:p2p-pane": "tsx test/e2e-obsidian/scripts/p2p-pane.ts",
         "test:e2e:obsidian:vault-reflection": "tsx test/e2e-obsidian/scripts/vault-reflection.ts",
@@ -70,6 +71,8 @@
         "test:e2e:obsidian:couchdb-manual-setup-workflow": "tsx test/e2e-obsidian/scripts/couchdb-manual-setup-workflow.ts",
         "test:e2e:obsidian:cli-to-obsidian-sync": "tsx test/e2e-obsidian/scripts/cli-to-obsidian-sync.ts",
         "test:e2e:obsidian:minio-upload": "tsx test/e2e-obsidian/scripts/minio-upload.ts",
+        "test:e2e:obsidian:adaptive-postgrest": "tsx test/e2e-obsidian/scripts/adaptive-postgrest.ts",
+        "test:e2e:obsidian:adaptive-postgrest:services": "tsx test/e2e-obsidian/scripts/adaptive-postgrest.ts --manage-postgrest",
         "test:e2e:obsidian:object-storage-setup-uri-workflow": "tsx test/e2e-obsidian/scripts/object-storage-setup-uri-workflow.ts",
         "test:e2e:obsidian:p2p-setup-uri-workflow": "tsx test/e2e-obsidian/scripts/p2p-setup-uri-workflow.ts",
         "pretest:e2e:obsidian:p2p-connection-check": "npm run build && npm run build --workspace webpeer",

src/common/messages/LiveSyncProvisionalMessages.ts

@@ -88,6 +88,43 @@ export const liveSyncProvisionalEnglishMessages = {
     "Store Journal data in a dedicated WebDAV collection. Adaptive mode is experimental and requires an endpoint safety check.":
         "Store Journal data in a dedicated WebDAV collection. Adaptive mode is experimental and requires an endpoint safety check.",
     "Continue to WebDAV setup": "Continue to WebDAV setup",
+    "PostgREST Journal Configuration": "PostgREST Journal Configuration",
+    "Connect to the packaged, Adaptive-only PostgREST RPC contract. This experimental provider is not a CouchDB endpoint and does not expose synchronisation tables directly.":
+        "Connect to the packaged, Adaptive-only PostgREST RPC contract. This experimental provider is not a CouchDB endpoint and does not expose synchronisation tables directly.",
+    "Enter a complete HTTP or HTTPS PostgREST endpoint without database credentials, a query string, or a fragment.":
+        "Enter a complete HTTP or HTTPS PostgREST endpoint without database credentials, a query string, or a fragment.",
+    "Vault ID": "Vault ID",
+    "Vault credential": "Vault credential",
+    "Enter the provisioned Vault credential": "Enter the provisioned Vault credential",
+    "A trusted database administrator obtains both values once from livesync_private.provision_adaptive_vault(). PostgreSQL retains only a verifier for the credential.":
+        "A trusted database administrator obtains both values once from livesync_private.provision_adaptive_vault(). PostgreSQL retains only a verifier for the credential.",
+    "Exposed schema": "Exposed schema",
+    "Client API key (optional)": "Client API key (optional)",
+    "Supabase publishable key, if required": "Supabase publishable key, if required",
+    "Use only a publishable or equivalent client-safe API key. Never enter a Supabase secret key, service_role JWT, or database credential.":
+        "Use only a publishable or equivalent client-safe API key. Never enter a Supabase secret key, service_role JWT, or database credential.",
+    "Supply a valid endpoint, PostgreSQL schema identifier, provisioned Vault ID, and Vault credential.":
+        "Supply a valid endpoint, PostgreSQL schema identifier, provisioned Vault ID, and Vault credential.",
+    "PostgREST stores only Adaptive Journal records. It cannot read Opaque Journal data, and format changes require a remote Rebuild rather than an in-place migration.":
+        "PostgREST stores only Adaptive Journal records. It cannot read Opaque Journal data, and format changes require a remote Rebuild rather than an in-place migration.",
+    "The required PostgREST RPC operations and binary semantics were verified.":
+        "The required PostgREST RPC operations and binary semantics were verified.",
+    "The PostgREST SQL contract is missing required operations: ${CAPABILITIES}.":
+        "The PostgREST SQL contract is missing required operations: ${CAPABILITIES}.",
+    "The PostgREST SQL contract is unavailable or incompatible with this build.":
+        "The PostgREST SQL contract is unavailable or incompatible with this build.",
+    "This build cannot inspect PostgREST Journal capabilities.":
+        "This build cannot inspect PostgREST Journal capabilities.",
+    "Invalid PostgREST settings: ${REASON}": "Invalid PostgREST settings: ${REASON}",
+    "The saved connection contains the Vault credential and optional API key. Configuration encryption protects exported Setup data when it is enabled; do not share a plain connection string.":
+        "The saved connection contains the Vault credential and optional API key. Configuration encryption protects exported Setup data when it is enabled; do not share a plain connection string.",
+    "PostgREST Journal": "PostgREST Journal",
+    "Store Adaptive Journal records through the packaged PostgREST SQL contract. This experimental provider requires a provisioned Vault credential, and onboarding requires a successful server capability check.":
+        "Store Adaptive Journal records through the packaged PostgREST SQL contract. This experimental provider requires a provisioned Vault credential, and onboarding requires a successful server capability check.",
+    "Continue to PostgREST setup": "Continue to PostgREST setup",
+    "Check PostgREST server": "Check PostgREST server",
+    "Saving without a successful connection test keeps this profile, but automatic synchronisation may fail until the connection or server SQL is corrected.":
+        "Saving without a successful connection test keeps this profile, but automatic synchronisation may fail until the connection or server SQL is corrected.",
     "Expected repository ID": "Expected repository ID",
     "This optional identity pins a trusted Adaptive repository. A Setup URI can supply it; leave it blank only when creating a repository or intentionally trusting the first compatible repository reached.":
         "This optional identity pins a trusted Adaptive repository. A Setup URI can supply it; leave it blank only when creating a repository or intentionally trusting the first compatible repository reached.",

src/modules/features/SettingDialogue/PaneRemoteConfig.ts

@@ -46,6 +46,16 @@ function serializeRemoteConfiguration(settings: ObsidianLiveSyncSettings): strin
     const configuration = defaultRemoteProviderRegistry.configurationFromSettings(type, settings);
     return defaultRemoteProviderRegistry.serialise(configuration);
 }
+
+function describeRemoteConfiguration(uri: string): string {
+    try {
+        const configuration = defaultRemoteProviderRegistry.parse(uri);
+        return defaultRemoteProviderRegistry.suggestName(configuration);
+    } catch {
+        return "";
+    }
+}
+
 function setEmojiButton(button: ButtonComponent, emoji: string, tooltip: string) {
     button.setButtonText(emoji);
     button.setTooltip(tooltip, { delay: 10, placement: "top" });

src/modules/features/SettingDialogue/remoteConfigBuffer.ts

@@ -2,6 +2,7 @@ import {
     pickBucketSyncSettings,
     pickCouchDBSyncSettings,
     pickP2PSyncSettings,
+    pickPostgRESTSyncSettings,
     pickWebDAVSyncSettings,
 } from "@vrtmrz/livesync-commonlib/compat/common/utils";
 import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
@@ -17,7 +18,14 @@ export function syncActivatedRemoteSettings(
         activeConfigurationId: source.activeConfigurationId,
         ...pickBucketSyncSettings(source),
         ...pickWebDAVSyncSettings(source),
+        ...pickPostgRESTSyncSettings(source),
         ...pickCouchDBSyncSettings(source),
         ...pickP2PSyncSettings(source),
+        // Provider pickers share these fields. Keep the active profile's protocol after
+        // collecting provider-specific connection fields so that one provider cannot
+        // normalise another provider's Journal policy.
+        expectedRepositoryId: source.expectedRepositoryId ?? "",
+        journalFormat: source.journalFormat ?? "opaque-v1",
+        packReadPolicy: source.packReadPolicy ?? "whole-pack",
     });
 }

src/modules/features/SettingDialogue/remoteConfigBuffer.unit.spec.ts

@@ -3,6 +3,7 @@ import {
     DEFAULT_SETTINGS,
     REMOTE_COUCHDB,
     REMOTE_MINIO,
+    REMOTE_POSTGREST,
     REMOTE_WEBDAV,
 } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { syncActivatedRemoteSettings } from "./remoteConfigBuffer";
@@ -121,4 +122,35 @@ describe("syncActivatedRemoteSettings", () => {
         expect(target.journalFormat).toBe("adaptive-v1");
         expect(target.packReadPolicy).toBe("range");
     });
+
+    it("should copy the active PostgREST connection and fixed Adaptive protocol into the editing buffer", () => {
+        const target = {
+            ...DEFAULT_SETTINGS,
+            remoteType: REMOTE_COUCHDB,
+            activeConfigurationId: "old-remote",
+            postgrestActiveConnectionURI: "",
+            expectedRepositoryId: "",
+            journalFormat: "opaque-v1" as const,
+            packReadPolicy: "range" as const,
+        };
+        const source = {
+            ...DEFAULT_SETTINGS,
+            remoteType: REMOTE_POSTGREST,
+            activeConfigurationId: "remote-postgrest",
+            postgrestActiveConnectionURI:
+                "sls+postgrest://vault-id-00000001:vault-credential@project.example/rest/v1?apiKey=publishable",
+            expectedRepositoryId: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+            journalFormat: "adaptive-v1" as const,
+            packReadPolicy: "whole-pack" as const,
+        };
+
+        syncActivatedRemoteSettings(target, source);
+
+        expect(target.remoteType).toBe(REMOTE_POSTGREST);
+        expect(target.activeConfigurationId).toBe("remote-postgrest");
+        expect(target.postgrestActiveConnectionURI).toBe(source.postgrestActiveConnectionURI);
+        expect(target.expectedRepositoryId).toBe(source.expectedRepositoryId);
+        expect(target.journalFormat).toBe("adaptive-v1");
+        expect(target.packReadPolicy).toBe("whole-pack");
+    });
 });

src/modules/features/SetupManager.ts

@@ -299,6 +299,21 @@ export class SetupManager extends AbstractModule {
         return await this.onRemoteManualSetup("webdav", userMode, currentSetting, activate);
     }
 
+    /**
+     * Handles manual setup for Adaptive Journal storage through PostgREST.
+     * @param userMode
+     * @param currentSetting
+     * @param activate Whether to activate PostgREST as the main remote type
+     * @returns Promise that resolves to true if setup completed successfully, false otherwise
+     */
+    async onPostgRESTManualSetup(
+        userMode: UserMode,
+        currentSetting: ObsidianLiveSyncSettings,
+        activate = true
+    ): Promise<boolean> {
+        return await this.onRemoteManualSetup("postgrest", userMode, currentSetting, activate);
+    }
+
     /**
      * Handles manual setup for P2P
      * @param userMode

src/modules/features/SetupManager.unit.spec.ts

@@ -4,6 +4,7 @@ import {
     REMOTE_COUCHDB,
     REMOTE_MINIO,
     REMOTE_P2P,
+    REMOTE_POSTGREST,
     REMOTE_WEBDAV,
     type ObsidianLiveSyncSettings,
 } from "@vrtmrz/livesync-commonlib/compat/common/types";
@@ -24,6 +25,7 @@ vi.mock("./SetupWizard/dialogs/SetupRemote.svelte", () => ({ default: {} }));
 vi.mock("./SetupWizard/dialogs/SetupRemoteCouchDB.svelte", () => ({ default: {} }));
 vi.mock("./SetupWizard/dialogs/SetupRemoteBucket.svelte", () => ({ default: {} }));
 vi.mock("./SetupWizard/dialogs/SetupRemoteWebDAV.svelte", () => ({ default: {} }));
+vi.mock("./SetupWizard/dialogs/SetupRemotePostgREST.svelte", () => ({ default: {} }));
 vi.mock("./SetupWizard/dialogs/SetupRemoteP2P.svelte", () => ({ default: {} }));
 vi.mock("./SetupWizard/dialogs/SetupRemoteE2EE.svelte", () => ({ default: {} }));
 
@@ -492,6 +494,8 @@ describe("SetupManager", () => {
             expect.arrayContaining([
                 expect.objectContaining({ type: "couchdb" }),
                 expect.objectContaining({ type: "s3" }),
+                expect.objectContaining({ type: "webdav" }),
+                expect.objectContaining({ type: "postgrest" }),
                 expect.objectContaining({ type: "p2p" }),
             ])
         );
@@ -653,6 +657,127 @@ describe("SetupManager", () => {
         });
     });
 
+    it("adds and activates a manually configured PostgREST profile without replacing existing profiles", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        setting.settings = {
+            ...setting.currentSettings(),
+            isConfigured: true,
+            remoteConfigurations: {
+                existing: {
+                    id: "existing",
+                    name: "Existing remote",
+                    uri: "sls+http://old:secret@old.example/?db=old",
+                    isEncrypted: false,
+                },
+            },
+            activeConfigurationId: "existing",
+        };
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({
+                postgrestActiveConnectionURI:
+                    "sls+postgrest://vault-id-00000001:vault-credential@project.example/rest/v1?apiKey=publishable",
+                expectedRepositoryId: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+                journalFormat: "adaptive-v1",
+                packReadPolicy: "whole-pack",
+            })
+            .mockResolvedValueOnce(true);
+
+        await manager.onPostgRESTManualSetup(UserMode.ExistingUser, setting.currentSettings());
+
+        const current = setting.currentSettings();
+        expect(current.remoteType).toBe(REMOTE_POSTGREST);
+        expect(current.remoteConfigurations.existing).toBeDefined();
+        expect(Object.keys(current.remoteConfigurations)).toHaveLength(2);
+        const activeProfile = current.remoteConfigurations[current.activeConfigurationId];
+        expect(activeProfile?.name).toBe("PostgREST project.example");
+        expect(activeProfile?.uri).toContain("sls+postgrest://vault-id-00000001:vault-credential@project.example");
+        expect(activeProfile?.uri).toContain("journalFormat=adaptive-v1");
+        expect(activeProfile?.uri).toContain("expectedRepositoryId=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
+        expect(ConnectionStringParser.parse(activeProfile?.uri ?? "")).toMatchObject({
+            type: "postgrest",
+            settings: { packReadPolicy: "whole-pack" },
+        });
+    });
+
+    it("preselects a repository identity during fresh Adaptive PostgREST onboarding", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({
+                postgrestActiveConnectionURI:
+                    "sls+postgrest://vault-id-00000001:vault-credential@project.example/rest/v1?apiKey=publishable",
+                expectedRepositoryId: "",
+                journalFormat: "adaptive-v1",
+                packReadPolicy: "whole-pack",
+            })
+            .mockResolvedValueOnce(true);
+
+        await manager.onPostgRESTManualSetup(UserMode.NewUser, setting.currentSettings());
+
+        const current = setting.currentSettings();
+        expect(current.expectedRepositoryId).toMatch(/^[A-Za-z0-9_-]{43}$/u);
+        const activeProfile = current.remoteConfigurations[current.activeConfigurationId];
+        expect(activeProfile?.uri).toContain(`expectedRepositoryId=${current.expectedRepositoryId}`);
+    });
+
+    it("leaves an existing-device Adaptive PostgREST attachment on trust on first use", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce({
+                postgrestActiveConnectionURI:
+                    "sls+postgrest://vault-id-00000001:vault-credential@project.example/rest/v1?apiKey=publishable",
+                expectedRepositoryId: "",
+                journalFormat: "adaptive-v1",
+                packReadPolicy: "whole-pack",
+            })
+            .mockResolvedValueOnce(true);
+
+        await manager.onPostgRESTManualSetup(UserMode.ExistingUser, setting.currentSettings());
+
+        const current = setting.currentSettings();
+        expect(current.expectedRepositoryId).toBe("");
+        const activeProfile = current.remoteConfigurations[current.activeConfigurationId];
+        expect(activeProfile?.uri).not.toContain("expectedRepositoryId=");
+    });
+
+    it.each([
+        [UserMode.NewUser, "onboarding"],
+        [UserMode.ExistingUser, "onboarding"],
+        [UserMode.Update, "settings"],
+    ] as const)("passes the %s PostgREST verification policy to the manual setup dialogue", async (userMode, mode) => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        dialogManager.openWithExplicitCancel.mockResolvedValueOnce("cancelled");
+        vi.spyOn(manager, "onOnboard").mockResolvedValue(false);
+
+        await manager.onPostgRESTManualSetup(userMode, setting.currentSettings());
+
+        expect(dialogManager.openWithExplicitCancel).toHaveBeenCalledWith(expect.anything(), {
+            settings: setting.currentSettings(),
+            mode,
+        });
+    });
+
+    it("routes a manual PostgREST selection through the registered setup provider", async () => {
+        const { manager, setting, dialogManager } = createSetupManager();
+        dialogManager.openWithExplicitCancel
+            .mockResolvedValueOnce("postgrest")
+            .mockResolvedValueOnce({
+                postgrestActiveConnectionURI:
+                    "sls+postgrest://vault-id-00000001:vault-credential@project.example/rest/v1?apiKey=publishable",
+                expectedRepositoryId: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+                journalFormat: "adaptive-v1",
+                packReadPolicy: "whole-pack",
+            })
+            .mockResolvedValueOnce(true);
+
+        await manager.onSelectServer(setting.currentSettings(), UserMode.NewUser);
+
+        expect(dialogManager.openWithExplicitCancel).toHaveBeenNthCalledWith(2, expect.anything(), {
+            settings: expect.anything(),
+            mode: "onboarding",
+        });
+        expect(setting.currentSettings().remoteType).toBe(REMOTE_POSTGREST);
+    });
+
     it("creates and selects a P2P profile during fresh manual onboarding", async () => {
         const { manager, setting, dialogManager } = createSetupManager();
         setting.settings = {

src/modules/features/SetupWizard/builtInRemoteSetupProviders.ts

@@ -5,12 +5,15 @@ import { $msg as translateMessage } from "@/common/translation";
 import SetupRemoteBucket from "./dialogs/SetupRemoteBucket.svelte";
 import SetupRemoteCouchDB from "./dialogs/SetupRemoteCouchDB.svelte";
 import SetupRemoteP2P from "./dialogs/SetupRemoteP2P.svelte";
+import SetupRemotePostgREST from "./dialogs/SetupRemotePostgREST.svelte";
 import SetupRemoteWebDAV from "./dialogs/SetupRemoteWebDAV.svelte";
 import type {
     SetupRemoteBucketResultType,
     SetupRemoteCouchDBInitialData,
     SetupRemoteCouchDBResultType,
     SetupRemoteP2PResultType,
+    SetupRemotePostgRESTInitialData,
+    SetupRemotePostgRESTResultType,
     SetupRemoteWebDAVInitialData,
     SetupRemoteWebDAVResultType,
 } from "./dialogs/setupDialogTypes";
@@ -121,11 +124,39 @@ export function useWebDAVRemoteSetup(
     return registry.register(descriptor);
 }
 
+export function usePostgRESTRemoteSetup(
+    registry: RemoteSetupRegistry<BuiltInRemoteConfiguration>
+): RemoteSetupRegistry<BuiltInRemoteConfiguration> {
+    const descriptor: RemoteSetupProviderDescriptor<ConfigurationOf<"postgrest">> = {
+        type: "postgrest",
+        choice: () => ({
+            title: translateMessage("PostgREST Journal"),
+            description: translateMessage(
+                "Store Adaptive Journal records through the packaged PostgREST SQL contract. This experimental provider requires a provisioned Vault credential, and onboarding requires a successful server capability check."
+            ),
+            proceedTitle: translateMessage("Continue to PostgREST setup"),
+        }),
+        open: async ({ dialogManager, intent, settings }) => {
+            const result = await dialogManager.openWithExplicitCancel<
+                SetupRemotePostgRESTResultType,
+                SetupRemotePostgRESTInitialData
+            >(SetupRemotePostgREST, {
+                settings,
+                mode: intent === "settings" ? "settings" : "onboarding",
+            });
+            return result === "cancelled" ? result : { type: "postgrest", settings: result };
+        },
+    };
+    assertSemanticProvider(descriptor.type);
+    return registry.register(descriptor);
+}
+
 export function createBuiltInRemoteSetupRegistry(): RemoteSetupRegistry<BuiltInRemoteConfiguration> {
     const registry = new RemoteSetupRegistry<BuiltInRemoteConfiguration>();
     useCouchDBRemoteSetup(registry);
     useS3RemoteSetup(registry);
     useWebDAVRemoteSetup(registry);
+    usePostgRESTRemoteSetup(registry);
     useP2PRemoteSetup(registry);
     return registry;
 }

src/modules/features/SetupWizard/dialogs/SetupRemotePostgREST.svelte

@@ -0,0 +1,380 @@
+<script lang="ts">
+    import { onMount } from "svelte";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import Guidance from "@/modules/services/LiveSyncUI/components/Guidance.svelte";
+    import Decision from "@/modules/services/LiveSyncUI/components/Decision.svelte";
+    import UserDecisions from "@/modules/services/LiveSyncUI/components/UserDecisions.svelte";
+    import InfoNote from "@/modules/services/LiveSyncUI/components/InfoNote.svelte";
+    import ExtraItems from "@/modules/services/LiveSyncUI/components/ExtraItems.svelte";
+    import InputRow from "@/modules/services/LiveSyncUI/components/InputRow.svelte";
+    import Password from "@/modules/services/LiveSyncUI/components/Password.svelte";
+    import { getDialogContext, type GuestDialogProps } from "@/modules/services/LiveSyncUI/svelteDialog";
+    import {
+        DEFAULT_SETTINGS,
+        PREFERRED_JOURNAL_SYNC,
+        type ObsidianLiveSyncSettings,
+    } from "@vrtmrz/livesync-commonlib/compat/common/types";
+    import {
+        REMOTE_POSTGREST,
+        isJournalStorageConnectionInspector,
+        type JournalStorageConnectivityResult,
+        type PostgRESTSyncSetting,
+    } from "@vrtmrz/livesync-commonlib/journal-storage";
+    import {
+        TYPE_CANCELLED,
+        type PostgRESTSetupMode,
+        type SetupRemotePostgRESTInitialData,
+        type SetupRemotePostgRESTResultType,
+    } from "./setupDialogTypes";
+    import {
+        postgRESTJournalFormFromSettings,
+        postgRESTSyncSettingsFromForm,
+        type PostgRESTJournalForm,
+    } from "./postgRESTJournalSettings";
+    import { $msg as translateMessage } from "@/common/translation";
+
+    let syncSetting = $state<PostgRESTJournalForm>(
+        postgRESTJournalFormFromSettings({
+            postgrestActiveConnectionURI: "",
+            expectedRepositoryId: "",
+            journalFormat: "adaptive-v1",
+            packReadPolicy: "whole-pack",
+        })
+    );
+    let setupMode = $state<PostgRESTSetupMode>("settings");
+    let error = $state("");
+    let processing = $state(false);
+    let inspection = $state<JournalStorageConnectivityResult | undefined>();
+    let inspectionFingerprint = $state("");
+    let inspectedSettings = $state<PostgRESTSyncSetting | undefined>();
+
+    type Props = GuestDialogProps<SetupRemotePostgRESTResultType, SetupRemotePostgRESTInitialData>;
+    const { setResult, getInitialData }: Props = $props();
+    const context = getDialogContext();
+
+    onMount(() => {
+        const initialData = getInitialData?.();
+        if (!initialData) return;
+        setupMode = initialData.mode;
+        try {
+            Object.assign(syncSetting, postgRESTJournalFormFromSettings(initialData.settings));
+        } catch (ex) {
+            error = translateMessage("Invalid PostgREST settings: ${REASON}", {
+                REASON: ex instanceof Error ? ex.message : `${ex}`,
+            });
+        }
+    });
+
+    const isEndpointInsecure = $derived.by(() => syncSetting.endpoint.trim().toLowerCase().startsWith("http://"));
+    const isEndpointValid = $derived.by(() => {
+        try {
+            const endpoint = new URL(syncSetting.endpoint.trim());
+            return (
+                (endpoint.protocol === "http:" || endpoint.protocol === "https:") &&
+                endpoint.username === "" &&
+                endpoint.password === "" &&
+                endpoint.search === "" &&
+                endpoint.hash === ""
+            );
+        } catch {
+            return false;
+        }
+    });
+    const isSchemaValid = $derived(/^[A-Za-z_][A-Za-z0-9_]*$/u.test(syncSetting.schema.trim()));
+    const isVaultIdValid = $derived(/^[A-Za-z0-9_-]{16,128}$/u.test(syncSetting.vaultId.trim()));
+    const isVaultCredentialValid = $derived(
+        syncSetting.vaultCredential.length > 0 && new TextEncoder().encode(syncSetting.vaultCredential).byteLength <= 512
+    );
+    const isConnectionValid = $derived(
+        isEndpointValid && isSchemaValid && isVaultIdValid && isVaultCredentialValid
+    );
+    const hasInvalidInput = $derived.by(
+        () =>
+            (syncSetting.endpoint.trim() !== "" ||
+                syncSetting.vaultId.trim() !== "" ||
+                syncSetting.vaultCredential !== "") &&
+            !isConnectionValid
+    );
+    const formFingerprint = $derived.by(() => JSON.stringify(syncSetting));
+    const inspectionIsCurrent = $derived(
+        inspection !== undefined && inspectionFingerprint !== "" && inspectionFingerprint === formFingerprint
+    );
+    const requiredCapability = $derived.by(() => {
+        if (!inspectionIsCurrent) return undefined;
+        return inspection?.adaptiveCapabilities?.required;
+    });
+
+    function generateSetting(postgRESTSettings: PostgRESTSyncSetting): ObsidianLiveSyncSettings {
+        return {
+            ...DEFAULT_SETTINGS,
+            ...PREFERRED_JOURNAL_SYNC,
+            remoteType: REMOTE_POSTGREST,
+            ...postgRESTSettings,
+        };
+    }
+
+    function explainUnavailable(result: JournalStorageConnectivityResult): string {
+        if (result.remoteFormat !== undefined && result.remoteFormat !== "empty" && result.remoteFormat !== "adaptive-v1") {
+            return translateMessage(
+                "The remote contains ${REMOTE_FORMAT} data, but this profile selects ${SELECTED_FORMAT}. Rebuild the remote or restore the matching format.",
+                { REMOTE_FORMAT: result.remoteFormat, SELECTED_FORMAT: "adaptive-v1" }
+            );
+        }
+        const required = result.adaptiveCapabilities?.required;
+        if (required?.status === "unsupported") {
+            return translateMessage("The PostgREST SQL contract is missing required operations: ${CAPABILITIES}.", {
+                CAPABILITIES: required.missing.join(", "),
+            });
+        }
+        if (required?.status === "failed") {
+            return translateMessage("The Adaptive safety check failed (${CATEGORY}; retry ${RETRY}).", {
+                CATEGORY: required.failure.category,
+                RETRY: required.failure.retry,
+            });
+        }
+        return translateMessage("The PostgREST SQL contract is unavailable or incompatible with this build.");
+    }
+
+    async function inspectConnection(trialRemoteSetting: ObsidianLiveSyncSettings, testedFingerprint: string) {
+        const replicator = await context.services.replicator.getNewReplicator(trialRemoteSetting);
+        if (!replicator) {
+            throw new Error(translateMessage("Failed to create replicator instance."));
+        }
+        if (!isJournalStorageConnectionInspector(replicator)) {
+            throw new Error(translateMessage("This build cannot inspect PostgREST Journal capabilities."));
+        }
+        const result = await replicator.inspectJournalStorageConnection(trialRemoteSetting);
+        inspection = result;
+        inspectionFingerprint = testedFingerprint;
+        return result;
+    }
+
+    async function checkConnection() {
+        error = "";
+        inspection = undefined;
+        inspectionFingerprint = "";
+        inspectedSettings = undefined;
+        processing = true;
+        try {
+            const testedFingerprint = formFingerprint;
+            const candidate = postgRESTSyncSettingsFromForm(syncSetting);
+            const trialRemoteSetting = generateSetting(candidate);
+            const result = await inspectConnection(trialRemoteSetting, testedFingerprint);
+            if (testedFingerprint !== formFingerprint) return;
+            if (!result.available) {
+                error = explainUnavailable(result);
+                return;
+            }
+            inspectedSettings = candidate;
+        } catch (ex) {
+            error = translateMessage("Error during connection test: ${reason}", {
+                reason: ex instanceof Error ? ex.message : `${ex}`,
+            });
+        } finally {
+            processing = false;
+        }
+    }
+
+    function commitVerified() {
+        if (!inspectionIsCurrent || !inspection?.available || !inspectedSettings) return;
+        setResult(inspectedSettings);
+    }
+
+    function commit() {
+        error = "";
+        if (!isConnectionValid) return;
+        try {
+            setResult(postgRESTSyncSettingsFromForm(syncSetting));
+        } catch (ex) {
+            error = translateMessage("Invalid PostgREST settings: ${REASON}", {
+                REASON: ex instanceof Error ? ex.message : `${ex}`,
+            });
+        }
+    }
+</script>
+
+<DialogHeader title={translateMessage("PostgREST Journal Configuration")} />
+<Guidance>
+    {translateMessage(
+        "Connect to the packaged, Adaptive-only PostgREST RPC contract. This experimental provider is not a CouchDB endpoint and does not expose synchronisation tables directly."
+    )}
+</Guidance>
+
+<InputRow label={translateMessage("Endpoint URL")}>
+    <input
+        type="text"
+        name="postgrest-endpoint"
+        placeholder="https://project.example/rest/v1"
+        autocorrect="off"
+        autocapitalize="off"
+        spellcheck="false"
+        required
+        pattern="^https?://.+"
+        bind:value={syncSetting.endpoint}
+    />
+</InputRow>
+<InfoNote warning visible={isEndpointInsecure}>
+    {translateMessage("We can use only Secure (HTTPS) connections on Obsidian Mobile.")}
+</InfoNote>
+<InfoNote error visible={syncSetting.endpoint.trim() !== "" && !isEndpointValid}>
+    {translateMessage(
+        "Enter a complete HTTP or HTTPS PostgREST endpoint without database credentials, a query string, or a fragment."
+    )}
+</InfoNote>
+
+<InputRow label={translateMessage("Vault ID")}>
+    <input
+        type="text"
+        name="postgrest-vault-id"
+        placeholder="provisioned-vault-id"
+        autocorrect="off"
+        autocapitalize="off"
+        spellcheck="false"
+        required
+        bind:value={syncSetting.vaultId}
+    />
+</InputRow>
+<InputRow label={translateMessage("Vault credential")}>
+    <Password
+        name="postgrest-vault-credential"
+        placeholder={translateMessage("Enter the provisioned Vault credential")}
+        required
+        bind:value={syncSetting.vaultCredential}
+    />
+</InputRow>
+<InfoNote>
+    {translateMessage(
+        "A trusted database administrator obtains both values once from livesync_private.provision_adaptive_vault(). PostgreSQL retains only a verifier for the credential."
+    )}
+</InfoNote>
+
+<InputRow label={translateMessage("Exposed schema")}>
+    <input
+        type="text"
+        name="postgrest-schema"
+        placeholder="livesync_api"
+        autocorrect="off"
+        autocapitalize="off"
+        spellcheck="false"
+        required
+        bind:value={syncSetting.schema}
+    />
+</InputRow>
+<InputRow label={translateMessage("Client API key (optional)")}>
+    <Password
+        name="postgrest-api-key"
+        placeholder={translateMessage("Supabase publishable key, if required")}
+        bind:value={syncSetting.apiKey}
+    />
+</InputRow>
+<InfoNote caution>
+    {translateMessage(
+        "Use only a publishable or equivalent client-safe API key. Never enter a Supabase secret key, service_role JWT, or database credential."
+    )}
+</InfoNote>
+<InfoNote error visible={hasInvalidInput}>
+    {translateMessage(
+        "Supply a valid endpoint, PostgreSQL schema identifier, provisioned Vault ID, and Vault credential."
+    )}
+</InfoNote>
+
+<InputRow label={translateMessage("Use internal API")}>
+    <input type="checkbox" name="postgrest-use-internal-api" bind:checked={syncSetting.useCustomRequestHandler} />
+</InputRow>
+<InfoNote>
+    {translateMessage(
+        "Enable this when browser-compatible requests are blocked by CORS. It uses Obsidian's internal request API and may behave differently from standard browser fetch."
+    )}
+</InfoNote>
+
+<ExtraItems title={translateMessage("Advanced Settings")}>
+    <InputRow label={translateMessage("Expected repository ID")}>
+        <input
+            type="text"
+            name="postgrest-expected-repository-id"
+            autocorrect="off"
+            autocapitalize="off"
+            spellcheck="false"
+            bind:value={syncSetting.expectedRepositoryId}
+        />
+    </InputRow>
+    <InfoNote>
+        {translateMessage(
+            "This optional identity pins a trusted Adaptive repository. A Setup URI can supply it; leave it blank only when creating a repository or intentionally trusting the first compatible repository reached."
+        )}
+    </InfoNote>
+</ExtraItems>
+
+<InfoNote warning>
+    {translateMessage(
+        "PostgREST stores only Adaptive Journal records. It cannot read Opaque Journal data, and format changes require a remote Rebuild rather than an in-place migration."
+    )}
+</InfoNote>
+{#if requiredCapability?.status === "verified"}
+    <InfoNote notice>
+        {translateMessage("The required PostgREST RPC operations and binary semantics were verified.")}
+    </InfoNote>
+{:else if requiredCapability?.status === "unsupported"}
+    <InfoNote error>
+        {translateMessage("The PostgREST SQL contract is missing required operations: ${CAPABILITIES}.", {
+            CAPABILITIES: requiredCapability.missing.join(", "),
+        })}
+    </InfoNote>
+{:else if requiredCapability?.status === "failed"}
+    <InfoNote error>
+        {translateMessage("The Adaptive safety check failed (${CATEGORY}; retry ${RETRY}).", {
+            CATEGORY: requiredCapability.failure.category,
+            RETRY: requiredCapability.failure.retry,
+        })}
+    </InfoNote>
+{:else if inspectionIsCurrent}
+    <InfoNote warning>{translateMessage("Required Adaptive operations were not checked.")}</InfoNote>
+{/if}
+
+<InfoNote>
+    {translateMessage(
+        "The saved connection contains the Vault credential and optional API key. Configuration encryption protects exported Setup data when it is enabled; do not share a plain connection string."
+    )}
+</InfoNote>
+<InfoNote error visible={error !== ""}>{error}</InfoNote>
+
+{#if processing}
+    {translateMessage("Checking connection... Please wait.")}
+{:else}
+    <UserDecisions>
+        {#if inspectionIsCurrent && inspection?.available && inspectedSettings}
+            <Decision
+                title={setupMode === "settings"
+                    ? translateMessage("Save verified settings")
+                    : translateMessage("Continue with verified settings")}
+                important
+                commit={() => commitVerified()}
+            />
+            <Decision
+                title={translateMessage("Check PostgREST server")}
+                disabled={!isConnectionValid}
+                commit={() => checkConnection()}
+            />
+        {:else}
+            <Decision
+                title={translateMessage("Check PostgREST server")}
+                important
+                disabled={!isConnectionValid}
+                commit={() => checkConnection()}
+            />
+        {/if}
+        {#if setupMode === "settings"}
+            <InfoNote warning>
+                {translateMessage(
+                    "Saving without a successful connection test keeps this profile, but automatic synchronisation may fail until the connection or server SQL is corrected."
+                )}
+            </InfoNote>
+            <Decision
+                title={translateMessage("Save without connecting")}
+                disabled={!isConnectionValid}
+                commit={() => commit()}
+            />
+        {/if}
+        <Decision title={translateMessage("Cancel")} commit={() => setResult(TYPE_CANCELLED)} />
+    </UserDecisions>
+{/if}

src/modules/features/SetupWizard/dialogs/postgRESTJournalSettings.ts

@@ -0,0 +1,65 @@
+import { DEFAULT_SETTINGS } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import {
+    REMOTE_POSTGREST,
+    journalProtocolConfigurationForSettings,
+    parsePostgRESTConnectionURI,
+    serialisePostgRESTConnectionURI,
+    type PostgRESTConnection,
+    type PostgRESTSyncSetting,
+} from "@vrtmrz/livesync-commonlib/journal-storage";
+
+export type PostgRESTJournalForm = PostgRESTConnection & {
+    expectedRepositoryId: string;
+};
+
+const emptyPostgRESTConnection: PostgRESTConnection = {
+    apiKey: "",
+    endpoint: "",
+    schema: "livesync_api",
+    useCustomRequestHandler: false,
+    vaultCredential: "",
+    vaultId: "",
+};
+
+function resolveProtocol(settings: PostgRESTSyncSetting) {
+    return journalProtocolConfigurationForSettings({
+        ...DEFAULT_SETTINGS,
+        remoteType: REMOTE_POSTGREST,
+        ...settings,
+        journalFormat: "adaptive-v1",
+        packReadPolicy: "whole-pack",
+    });
+}
+
+export function postgRESTJournalFormFromSettings(settings: PostgRESTSyncSetting): PostgRESTJournalForm {
+    const activeConnectionURI = settings.postgrestActiveConnectionURI.trim();
+    const connection = activeConnectionURI
+        ? parsePostgRESTConnectionURI(activeConnectionURI)
+        : emptyPostgRESTConnection;
+    const protocol = resolveProtocol({
+        ...settings,
+        expectedRepositoryId: activeConnectionURI ? settings.expectedRepositoryId : "",
+    });
+    return {
+        ...connection,
+        expectedRepositoryId: protocol.expectedRepositoryId,
+    };
+}
+
+export function postgRESTSyncSettingsFromForm(form: PostgRESTJournalForm): PostgRESTSyncSetting {
+    const settings: PostgRESTSyncSetting = {
+        postgrestActiveConnectionURI: serialisePostgRESTConnectionURI({
+            apiKey: form.apiKey.trim(),
+            endpoint: form.endpoint.trim(),
+            schema: form.schema.trim(),
+            useCustomRequestHandler: form.useCustomRequestHandler,
+            vaultCredential: form.vaultCredential,
+            vaultId: form.vaultId.trim(),
+        }),
+        expectedRepositoryId: form.expectedRepositoryId.trim(),
+        journalFormat: "adaptive-v1",
+        packReadPolicy: "whole-pack",
+    };
+    resolveProtocol(settings);
+    return settings;
+}

src/modules/features/SetupWizard/dialogs/postgRESTJournalSettings.unit.spec.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+
+import { serialisePostgRESTConnectionURI } from "@vrtmrz/livesync-commonlib/journal-storage";
+import { postgRESTJournalFormFromSettings, postgRESTSyncSettingsFromForm } from "./postgRESTJournalSettings.ts";
+
+const repositoryId = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+
+describe("PostgREST Journal settings", () => {
+    it("round-trips client connection fields with the fixed Adaptive protocol", () => {
+        const settings = {
+            postgrestActiveConnectionURI: serialisePostgRESTConnectionURI({
+                apiKey: "publishable-key",
+                endpoint: "https://project.example/rest/v1",
+                schema: "private_sync",
+                useCustomRequestHandler: true,
+                vaultCredential: "credential with spaces",
+                vaultId: "vault-id-00000001",
+            }),
+            expectedRepositoryId: repositoryId,
+            journalFormat: "adaptive-v1" as const,
+            packReadPolicy: "whole-pack" as const,
+        };
+
+        const form = postgRESTJournalFormFromSettings(settings);
+
+        expect(form).toEqual({
+            apiKey: "publishable-key",
+            endpoint: "https://project.example/rest/v1",
+            expectedRepositoryId: repositoryId,
+            schema: "private_sync",
+            useCustomRequestHandler: true,
+            vaultCredential: "credential with spaces",
+            vaultId: "vault-id-00000001",
+        });
+        expect(postgRESTSyncSettingsFromForm(form)).toEqual(settings);
+    });
+
+    it("uses the exposed-schema default for a new profile", () => {
+        expect(
+            postgRESTJournalFormFromSettings({
+                postgrestActiveConnectionURI: "",
+                expectedRepositoryId: repositoryId,
+                journalFormat: "opaque-v1",
+                packReadPolicy: "range",
+            })
+        ).toEqual({
+            apiKey: "",
+            endpoint: "",
+            expectedRepositoryId: "",
+            schema: "livesync_api",
+            useCustomRequestHandler: false,
+            vaultCredential: "",
+            vaultId: "",
+        });
+    });
+
+    it("rejects an invalid pinned repository identity", () => {
+        expect(() =>
+            postgRESTSyncSettingsFromForm({
+                apiKey: "publishable-key",
+                endpoint: "https://project.example/rest/v1",
+                expectedRepositoryId: "AA",
+                schema: "livesync_api",
+                useCustomRequestHandler: false,
+                vaultCredential: "vault-credential",
+                vaultId: "vault-id-00000001",
+            })
+        ).toThrow("expectedRepositoryId must be a canonical base64url-encoded 32-byte value");
+    });
+});

src/modules/features/SetupWizard/dialogs/setupDialogTypes.ts

@@ -4,6 +4,7 @@ import type {
     EncryptionSettings,
     ObsidianLiveSyncSettings,
     P2PConnectionInfo,
+    PostgRESTSyncSetting,
     WebDAVSyncSetting,
 } from "@vrtmrz/livesync-commonlib/compat/common/models/setting.type";
 import type { BuiltInRemoteConfiguration } from "@vrtmrz/livesync-commonlib/remote-configurations";
@@ -112,6 +113,13 @@ export type SetupRemoteWebDAVInitialData = {
     mode: WebDAVSetupMode;
 };
 
+export type SetupRemotePostgRESTResultType = typeof TYPE_CANCELLED | PostgRESTSyncSetting;
+export type PostgRESTSetupMode = "onboarding" | "settings";
+export type SetupRemotePostgRESTInitialData = {
+    settings: PostgRESTSyncSetting;
+    mode: PostgRESTSetupMode;
+};
+
 export type SetupRemoteCouchDBResultType = typeof TYPE_CANCELLED | CouchDBConnection;
 export type CouchDBSetupMode = "create-or-connect" | "connect-existing" | "settings";
 export type SetupRemoteCouchDBInitialData = {

test/e2e-obsidian/README.md

@@ -76,9 +76,10 @@ After changing plug-in source, use the focused wrapper rather than invoking a sc
 npm run test:e2e:obsidian:focused -- settings-ui
 npm run test:e2e:obsidian:focused -- two-vault-sync
 npm run test:e2e:obsidian:focused -- security-seed-reconnect
+npm run test:e2e:obsidian:focused -- adaptive-postgrest --manage-postgrest
 ```
 
-The wrapper accepts only maintained real-Obsidian scenario names; run it with `--help` for the current list. It deliberately does not manage CouchDB, Object Storage, or the P2P signalling relay. Start the required fixture first, or use the complete service-managed suite.
+The wrapper accepts only maintained real-Obsidian scenario names; run it with `--help` for the current list. It deliberately does not manage CouchDB, Object Storage, PostgREST, or the P2P signalling relay unless a focused scenario exposes its own explicit service-management argument. Start the required fixture first, pass `--manage-postgrest` to the Adaptive PostgREST scenario, or use the complete service-managed suite.
 
 The principal entry points are:
 
@@ -147,6 +148,8 @@ LIVESYNC_CLI_COMMAND="docker run --rm --network host --user $(id -u):$(id -g) --
 
 `test:e2e:obsidian:minio-upload` reuses the Object Storage variables from `.test.env` or the process environment. It expects a reachable S3-compatible service and starts with isolated Object Storage settings and the device-local compatibility acknowledgement already in place, keeping the scenario focused on upload rather than unconfigured start-up or setup. It confirms those settings through `obsidian-cli eval`, creates a note in real Obsidian, runs one-shot Journal Sync, and verifies through the AWS SDK that objects were written under a unique bucket prefix. Adapter tests separately observe an in-progress SDK command, while this real-runtime workflow verifies the resulting request counters advance and rebalance.
 
+`test:e2e:obsidian:adaptive-postgrest` applies the two-device real-Obsidian workflow to the Adaptive-only PostgREST provider. Visible manual onboarding must withhold continuation until the packaged RPC and binary-semantics check succeeds, and it must not expose Opaque or Pack retrieval choices. The first device retains its profile across a real Obsidian restart, generates a Setup URI for the second device, and completes Fast Fetch and a text and binary return journey. This representative native-store journey verifies Host composition and user-observable Vault reflection. Commonlib integration tests own the RPC failure matrix, SQL transaction semantics, repository binding, and remote layout. Rebuild resets all Adaptive data for the supplied Vault ID, so external settings must identify a disposable test Vault. Run `test:e2e:obsidian:adaptive-postgrest:services`, or pass `--manage-postgrest` through the focused wrapper, to start and stop the shared PostgreSQL and PostgREST fixture around this scenario.
+
 `test:e2e:obsidian:object-storage-setup-uri-workflow` uses the public Commonlib-backed tool to generate the initial Setup URI for a unique MinIO prefix, completes visible initialisation on the first device, and then asks that working real Obsidian device to create a new Setup URI through the registered command. A second real Obsidian device imports only the device-generated URI. The workflow verifies A-to-B and B-to-A notes, captures the documented onboarding choices, and removes the Object Storage prefix only after both sessions have stopped.
 
 `test:e2e:obsidian:p2p-setup-uri-workflow` runs two concurrent isolated real Obsidian sessions against the local Compose Nostr relay fixture. The first device imports a generated initial Setup URI and completes its signalling test with zero peers, creates a Setup URI for the second device through the registered command, and remains online while the second device imports it. The second device must select the expected online source before Fetch can rebuild its local database. The workflow accepts each connection request visibly on the receiving device, verifies the initial A-to-B fetch, checks that the menu for the three persistent per-peer actions remains within the viewport, reconnects both P2P sessions in join order, and verifies the B-to-A return journey. Every started session remains tracked until teardown completes.
@@ -198,6 +201,7 @@ Start the local fixtures first when they are not already running:
 ```bash
 npm run test:docker-couchdb:start
 npm run test:docker-s3:start
+npm run test:docker-postgrest:start
 npm run test:docker-p2p:start
 npm run test:e2e:obsidian:local-suite
 ```
@@ -246,6 +250,7 @@ Useful environment variables:
 - `E2E_OBSIDIAN_REMOTE_ACTIVITY_TIMEOUT_MS`: timeout for an observed remote activity to enter or leave its status boundary; default is 30 seconds.
 - `E2E_OBSIDIAN_DIAGNOSTICS_DIR`: directory for screenshots and status snapshots, including the Security Seed reconnect stages; default is `/tmp/obsidian-livesync-e2e`.
 - `E2E_OBSIDIAN_OBJECT_STORAGE_TIMEOUT_MS`: timeout for waiting until Object Storage contains uploaded E2E objects.
+- `POSTGREST_ENDPOINT`, `POSTGREST_SCHEMA`, `POSTGREST_VAULT_ID`, `POSTGREST_VAULT_CREDENTIAL`, and `POSTGREST_API_KEY`: external PostgREST fixture settings. The API key must be publishable or otherwise client-safe. The managed fixture supplies disposable defaults.
 - `E2E_OBSIDIAN_KEEP_COUCHDB=true`: keep the temporary CouchDB database for inspection.
 - `E2E_OBSIDIAN_KEEP_OBJECT_STORAGE=true`: keep the temporary Object Storage prefix for inspection.
 - `E2E_OBSIDIAN_STARTUP_GRACE_MS`: early process-exit detection window in milliseconds.

test/e2e-obsidian/runner/adaptiveJournal.ts

@@ -0,0 +1,384 @@
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { evalObsidianJson } from "./cli.ts";
+import { discoverObsidianCli, requireObsidianBinary } from "./environment.ts";
+import {
+    assertEqual,
+    pushLocalChanges,
+    waitForLiveSyncCoreReady,
+    waitForLocalDatabaseEntry,
+} from "./liveSyncWorkflow.ts";
+import { REMOTE_ACTIVITY_EXPECTED_STATE, waitForRemoteActivityState } from "./remoteActivity.ts";
+import { startObsidianLiveSyncSession, type ObsidianLiveSyncSession } from "./session.ts";
+import {
+    acknowledgeDisabledOptionalFeatures,
+    captureAndStartInitialisation,
+    confirmFastFetch,
+    confirmRebuild,
+    enterSetupURI,
+    finishInitialisation,
+    generateSetupURIFromDevice,
+    modalByTitle,
+    readSetupState,
+    resumeCompatibilityReviewIfShown,
+    skipMissingRemoteConfiguration,
+    type SetupArtifact,
+    type SetupCaptureNames,
+    type SetupState,
+} from "./setupUri.ts";
+import { captureObsidianPage, withObsidianPage } from "./ui.ts";
+import { createTemporaryVault, type TemporaryVault } from "./vault.ts";
+
+process.env.E2E_OBSIDIAN_CLI_TIMEOUT_MS ??= "90000";
+process.env.E2E_OBSIDIAN_SETUP_INITIALISATION_TIMEOUT_MS ??= "180000";
+
+const uiTimeoutMs = Number(process.env.E2E_OBSIDIAN_SETUP_URI_TIMEOUT_MS ?? 30000);
+const binaryLength = 256 * 1024;
+const firstBinarySeed = 0x1a2b3c4d;
+const secondBinarySeed = 0x5e6f7788;
+
+type RunnerContext = {
+    binary: string;
+    cliBinary: string;
+    activeSessions: Set<ObsidianLiveSyncSession>;
+};
+
+export type AdaptiveJournalObsidianScenario = {
+    /** Human-readable provider name, for example, 'Adaptive WebDAV'. */
+    label: string;
+    /** Stable lowercase name used for paths, screenshots, and setup captures. */
+    slug: string;
+    targetDescription: string;
+    enterManualSettings(port: number, vaultPassphrase: string): Promise<string[]>;
+    assertSettings(state: SetupState, label: string): void;
+};
+
+function assertRepositoryIdentity(state: SetupState, label: string, expectedRepositoryId?: string): string {
+    if (!/^[A-Za-z0-9_-]{43}$/u.test(state.expectedRepositoryId)) {
+        throw new Error(`${label} did not retain a canonical repository ID.`);
+    }
+    if (expectedRepositoryId !== undefined) {
+        assertEqual(state.expectedRepositoryId, expectedRepositoryId, `${label} retained a different repository ID.`);
+    }
+    return state.expectedRepositoryId;
+}
+
+function npmBinary(): string {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+
+export function runNpmScript(script: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const child = spawn(npmBinary(), ["run", script], {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: "inherit",
+        });
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${script} failed with ${signal ? `signal ${signal}` : `exit code ${code}`}.`));
+        });
+    });
+}
+
+async function dismissRedundantExternalOpenPrompt(port: number): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        const prompt = modalByTitle(page, "Run action from external link?");
+        if (!(await prompt.isVisible({ timeout: 2000 }).catch(() => false))) return;
+        await prompt.getByRole("button", { name: "Cancel", exact: true }).click({ timeout: uiTimeoutMs });
+        await prompt.waitFor({ state: "hidden", timeout: uiTimeoutMs });
+    });
+}
+
+async function startSession(context: RunnerContext, vault: TemporaryVault): Promise<ObsidianLiveSyncSession> {
+    const session = await startObsidianLiveSyncSession({
+        binary: context.binary,
+        cliBinary: context.cliBinary,
+        vault,
+        startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
+    });
+    context.activeSessions.add(session);
+    // Obsidian 1.12 can ask whether to repeat the CLI's 'open' action when the
+    // isolated profile has already restored this exact Vault. The session has
+    // already verified the active Vault, so dismiss only that redundant host
+    // prompt before exercising LiveSync UI.
+    await dismissRedundantExternalOpenPrompt(session.remoteDebuggingPort);
+    return session;
+}
+
+async function stopSession(context: RunnerContext, session: ObsidianLiveSyncSession): Promise<void> {
+    if (!context.activeSessions.has(session)) return;
+    await session.app.stop();
+    context.activeSessions.delete(session);
+}
+
+async function stopSessions(context: RunnerContext): Promise<void> {
+    for (const session of [...context.activeSessions]) await stopSession(context, session);
+}
+
+async function captureFailure(
+    session: ObsidianLiveSyncSession,
+    scenario: AdaptiveJournalObsidianScenario,
+    label: string
+): Promise<void> {
+    const screenshot = await captureObsidianPage(
+        session.remoteDebuggingPort,
+        `${scenario.slug}-${label}-failure.png`,
+        async () => undefined
+    ).catch(() => undefined);
+    if (screenshot) console.error(`${scenario.label} failure screenshot: ${screenshot}`);
+}
+
+function deterministicBytes(length: number, seed: number): Uint8Array {
+    const bytes = new Uint8Array(length);
+    let state = seed;
+    for (let index = 0; index < bytes.byteLength; index += 1) {
+        state ^= state << 13;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        bytes[index] = state & 0xff;
+    }
+    return bytes;
+}
+
+async function writePayloadViaObsidian(
+    cliBinary: string,
+    environment: NodeJS.ProcessEnv,
+    textPath: string,
+    binaryPath: string,
+    text: string,
+    binarySeed: number
+): Promise<void> {
+    await evalObsidianJson<unknown>(
+        cliBinary,
+        [
+            "(async()=>{",
+            `const textPath=${JSON.stringify(textPath)};`,
+            `const binaryPath=${JSON.stringify(binaryPath)};`,
+            `const text=${JSON.stringify(text)};`,
+            `const binaryLength=${JSON.stringify(binaryLength)};`,
+            `let state=${JSON.stringify(binarySeed)};`,
+            "let folder='';",
+            "for(const part of textPath.split('/').slice(0,-1)){",
+            "folder=folder?`${folder}/${part}`:part;",
+            "if(!(await app.vault.adapter.exists(folder))) await app.vault.createFolder(folder);",
+            "}",
+            "const existingText=app.vault.getAbstractFileByPath(textPath);",
+            "if(existingText) await app.vault.modify(existingText,text);",
+            "else await app.vault.create(textPath,text);",
+            "const bytes=new Uint8Array(binaryLength);",
+            "for(let i=0;i<bytes.byteLength;i++){",
+            "state^=state<<13;state^=state>>>17;state^=state<<5;bytes[i]=state&0xff;",
+            "}",
+            "const existingBinary=app.vault.getAbstractFileByPath(binaryPath);",
+            "if(existingBinary) await app.vault.modifyBinary(existingBinary,bytes.buffer);",
+            "else await app.vault.createBinary(binaryPath,bytes.buffer);",
+            "return JSON.stringify({ok:true});",
+            "})()",
+        ].join(""),
+        environment
+    );
+    await waitForLocalDatabaseEntry(cliBinary, environment, textPath);
+    await waitForLocalDatabaseEntry(cliBinary, environment, binaryPath);
+}
+
+async function waitForText(vault: TemporaryVault, textPath: string, expected: string): Promise<void> {
+    const deadline = Date.now() + Number(process.env.E2E_OBSIDIAN_FILE_TIMEOUT_MS ?? 30000);
+    let lastContent = "";
+    while (Date.now() < deadline) {
+        try {
+            lastContent = await readFile(join(vault.path, textPath), "utf8");
+            if (lastContent === expected) return;
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`Timed out waiting for ${textPath}. Last content:\n${lastContent}`);
+}
+
+async function waitForBinary(vault: TemporaryVault, binaryPath: string, expected: Uint8Array): Promise<void> {
+    const deadline = Date.now() + Number(process.env.E2E_OBSIDIAN_FILE_TIMEOUT_MS ?? 30000);
+    let lastLength = -1;
+    while (Date.now() < deadline) {
+        try {
+            const actual = await readFile(join(vault.path, binaryPath));
+            lastLength = actual.byteLength;
+            if (actual.byteLength === expected.byteLength && actual.equals(Buffer.from(expected))) return;
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`Timed out waiting for ${binaryPath}; last length was ${lastLength}.`);
+}
+
+async function pushAndObserve(
+    scenario: AdaptiveJournalObsidianScenario,
+    session: ObsidianLiveSyncSession,
+    cliBinary: string
+): Promise<number> {
+    const before = await waitForRemoteActivityState(session.remoteDebuggingPort, REMOTE_ACTIVITY_EXPECTED_STATE.idle);
+    await pushLocalChanges(cliBinary, session.cliEnv);
+    const after = await waitForRemoteActivityState(session.remoteDebuggingPort, REMOTE_ACTIVITY_EXPECTED_STATE.idle);
+    if (after.requestCount <= before.requestCount) {
+        throw new Error(`${scenario.label} synchronisation did not advance the tracked remote-request count.`);
+    }
+    assertEqual(
+        after.responseCount,
+        after.requestCount,
+        `${scenario.label} remote-request counters did not rebalance after synchronisation.`
+    );
+    return after.requestCount - before.requestCount;
+}
+
+export async function runAdaptiveJournalObsidianRoundTrip(scenario: AdaptiveJournalObsidianScenario): Promise<void> {
+    const binary = requireObsidianBinary();
+    const cli = discoverObsidianCli();
+    if (!cli.binary) throw new Error(`Could not find obsidian-cli. Checked paths: ${cli.checked.join(", ")}`);
+
+    const vaultPassphrase = randomBytes(24).toString("base64url");
+    const vaultA = await createTemporaryVault();
+    const vaultB = await createTemporaryVault();
+    const context: RunnerContext = { binary, cliBinary: cli.binary, activeSessions: new Set() };
+    const captures: SetupCaptureNames = { scenario: scenario.slug, guide: scenario.slug };
+    const secondDeviceCaptures: SetupCaptureNames = {
+        scenario: `${scenario.slug}-second-device`,
+        guide: `${scenario.slug}-second-device`,
+    };
+    const textPath = `E2E/${scenario.slug}/round-trip.md`;
+    const binaryPath = `E2E/${scenario.slug}/round-trip.bin`;
+    const firstText = `# ${scenario.label}\n\nCreated by the first real Obsidian device.\n`;
+    const secondText = `# ${scenario.label}\n\nUpdated by the second real Obsidian device.\n`;
+    const screenshots: string[] = [];
+    let generatedSetup: SetupArtifact | undefined;
+    let observedRequests = 0;
+    let repositoryId = "";
+
+    try {
+        console.log(`Using Obsidian executable: ${binary}`);
+        console.log(`Temporary Vault A: ${vaultA.path}`);
+        console.log(`Temporary Vault B: ${vaultB.path}`);
+        console.log(scenario.targetDescription);
+
+        let session = await startSession(context, vaultA);
+        try {
+            screenshots.push(...(await scenario.enterManualSettings(session.remoteDebuggingPort, vaultPassphrase)));
+            screenshots.push(await captureAndStartInitialisation(session.remoteDebuggingPort, "new", captures));
+            screenshots.push(await confirmRebuild(session.remoteDebuggingPort, captures));
+            screenshots.push(await skipMissingRemoteConfiguration(session.remoteDebuggingPort, captures));
+            screenshots.push(await acknowledgeDisabledOptionalFeatures(session.remoteDebuggingPort, captures));
+            const state = await finishInitialisation(session.remoteDebuggingPort, context.cliBinary, session.cliEnv);
+            await resumeCompatibilityReviewIfShown(session.remoteDebuggingPort);
+            scenario.assertSettings(state, "The first device");
+            repositoryId = assertRepositoryIdentity(state, "The first device");
+
+            await writePayloadViaObsidian(
+                context.cliBinary,
+                session.cliEnv,
+                textPath,
+                binaryPath,
+                firstText,
+                firstBinarySeed
+            );
+            observedRequests += await pushAndObserve(scenario, session, context.cliBinary);
+        } catch (error) {
+            await captureFailure(session, scenario, "first-device");
+            throw error;
+        } finally {
+            await stopSession(context, session);
+        }
+
+        session = await startSession(context, vaultA);
+        try {
+            await waitForLiveSyncCoreReady(context.cliBinary, session.cliEnv);
+            await resumeCompatibilityReviewIfShown(session.remoteDebuggingPort);
+            const state = await readSetupState(context.cliBinary, session.cliEnv);
+            scenario.assertSettings(state, "The restarted first device");
+            assertRepositoryIdentity(state, "The restarted first device", repositoryId);
+            const generated = await generateSetupURIFromDevice(
+                session.remoteDebuggingPort,
+                randomBytes(24).toString("base64url"),
+                captures
+            );
+            generatedSetup = generated.artifact;
+            screenshots.push(...generated.screenshots);
+        } catch (error) {
+            await captureFailure(session, scenario, "first-device-restart");
+            throw error;
+        } finally {
+            await stopSession(context, session);
+        }
+
+        session = await startSession(context, vaultB);
+        try {
+            if (!generatedSetup) throw new Error("The first device did not generate a Setup URI.");
+            screenshots.push(
+                await enterSetupURI(session.remoteDebuggingPort, "existing", generatedSetup, secondDeviceCaptures)
+            );
+            screenshots.push(
+                await captureAndStartInitialisation(session.remoteDebuggingPort, "existing", secondDeviceCaptures)
+            );
+            screenshots.push(...(await confirmFastFetch(session.remoteDebuggingPort, secondDeviceCaptures)));
+            // Journal remotes do not expose the legacy remote-configuration
+            // document. The device-generated Setup URI is the authoritative
+            // connection input, so acknowledge its expected absence explicitly.
+            screenshots.push(await skipMissingRemoteConfiguration(session.remoteDebuggingPort, secondDeviceCaptures));
+            const state = await finishInitialisation(session.remoteDebuggingPort, context.cliBinary, session.cliEnv);
+            await resumeCompatibilityReviewIfShown(session.remoteDebuggingPort);
+            scenario.assertSettings(state, "The second device");
+            assertRepositoryIdentity(state, "The second device", repositoryId);
+            observedRequests += await pushAndObserve(scenario, session, context.cliBinary);
+            await waitForText(vaultB, textPath, firstText);
+            await waitForBinary(vaultB, binaryPath, deterministicBytes(binaryLength, firstBinarySeed));
+
+            await writePayloadViaObsidian(
+                context.cliBinary,
+                session.cliEnv,
+                textPath,
+                binaryPath,
+                secondText,
+                secondBinarySeed
+            );
+            observedRequests += await pushAndObserve(scenario, session, context.cliBinary);
+        } catch (error) {
+            await captureFailure(session, scenario, "second-device");
+            throw error;
+        } finally {
+            await stopSession(context, session);
+        }
+
+        session = await startSession(context, vaultA);
+        try {
+            await waitForLiveSyncCoreReady(context.cliBinary, session.cliEnv);
+            await resumeCompatibilityReviewIfShown(session.remoteDebuggingPort);
+            const state = await readSetupState(context.cliBinary, session.cliEnv);
+            scenario.assertSettings(state, "The final first-device session");
+            assertRepositoryIdentity(state, "The final first-device session", repositoryId);
+            observedRequests += await pushAndObserve(scenario, session, context.cliBinary);
+            await waitForText(vaultA, textPath, secondText);
+            await waitForBinary(vaultA, binaryPath, deterministicBytes(binaryLength, secondBinarySeed));
+        } catch (error) {
+            await captureFailure(session, scenario, "return-journey");
+            throw error;
+        } finally {
+            await stopSession(context, session);
+        }
+
+        console.log(
+            `${scenario.label} passed visible safety-gated onboarding, restart persistence, a device-generated Setup URI, and a two-device text and binary return journey. Tracked requests across measured synchronisations: ${observedRequests}. Screenshots: ${screenshots.join(", ")}`
+        );
+    } finally {
+        await stopSessions(context).catch((error: unknown) => {
+            console.warn(error instanceof Error ? error.message : error);
+        });
+        await vaultA.dispose();
+        await vaultB.dispose();
+    }
+}

test/e2e-obsidian/runner/remoteSetupUi.ts

@@ -0,0 +1,330 @@
+import type { Locator, Page } from "playwright";
+import { captureObsidianDialogue, withObsidianPage } from "./ui.ts";
+
+const remoteSetupStateKey = "__livesyncE2ERemoteSetup";
+
+export type RemoteInspectionMode = "failed" | "verified";
+
+export type RemoteSetupCall = {
+    journalFormat: string;
+    operation: "create" | "inspect" | "test";
+    remoteType: string;
+};
+
+type RemoteSetupBrowserState = {
+    calls: RemoteSetupCall[];
+    inspectionMode: RemoteInspectionMode;
+    nextProfileName: string;
+    unregister?: () => void;
+};
+
+type RuntimeRemoteConfiguration = {
+    id: string;
+    isEncrypted: boolean;
+    name: string;
+    uri: string;
+};
+
+type RuntimeSettings = {
+    activeConfigurationId: string;
+    remoteConfigurations: Record<string, RuntimeRemoteConfiguration>;
+};
+
+type RuntimePlugin = {
+    core: {
+        services: {
+            replicator: {
+                getNewReplicator: {
+                    addHandler: (...args: unknown[]) => () => void;
+                } & ((settingOverride?: Record<string, unknown>) => Promise<unknown>);
+            };
+            setting: {
+                currentSettings(): RuntimeSettings;
+            };
+            UI: {
+                confirm: {
+                    askString(
+                        title: string,
+                        label: string,
+                        placeholder: string,
+                        isPassword?: boolean
+                    ): Promise<string | false>;
+                };
+            };
+        };
+    };
+};
+
+type RuntimeSettingsController = {
+    close(): void;
+    open(): void;
+    openTabById(tabId: string): void;
+};
+
+type RuntimeApp = {
+    plugins?: { plugins: Record<string, RuntimePlugin | undefined> };
+    setting?: RuntimeSettingsController;
+};
+
+type RuntimeGlobal = typeof globalThis & {
+    app?: RuntimeApp;
+    [remoteSetupStateKey]?: RemoteSetupBrowserState;
+};
+
+export function remoteSelectionModal(page: Page): Locator {
+    return page.locator(".modal-container").filter({
+        has: page.locator(".modal-title").filter({ hasText: "Choose a synchronisation remote" }),
+    });
+}
+
+export function remoteProviderModal(page: Page, title: string): Locator {
+    return page.locator(".modal-container").filter({
+        has: page.locator(".modal-title").filter({ hasText: title }),
+    });
+}
+
+export function remoteConfigurationPanel(page: Page): Locator {
+    return page
+        .locator(".sls-setting h4.sls-setting-panel-title")
+        .filter({ hasText: "Connection settings" })
+        .locator("..");
+}
+
+function remoteProfileRow(page: Page, profileName: string): Locator {
+    return remoteConfigurationPanel(page).locator(".sls-remote-list .setting-item").filter({ hasText: profileName });
+}
+
+async function tooltipButton(container: Locator, label: string, fallbackText: string): Promise<Locator> {
+    const labelled = container.locator(`button[aria-label="${label}"], button[title="${label}"]`);
+    if ((await labelled.count()) > 0) return labelled.first();
+    return container.locator("button").filter({ hasText: fallbackText }).first();
+}
+
+export async function installRemoteSetupTestSeam(port: number): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        await page.evaluate((stateKey) => {
+            const runtime = globalThis as RuntimeGlobal;
+            const plugin = runtime.app?.plugins?.plugins["obsidian-livesync"];
+            if (!plugin) throw new Error("Self-hosted LiveSync is not loaded");
+            const state: RemoteSetupBrowserState = {
+                calls: [],
+                inspectionMode: "verified",
+                nextProfileName: "",
+            };
+            runtime[stateKey as typeof remoteSetupStateKey] = state;
+
+            const getNewReplicator = plugin.core.services.replicator.getNewReplicator;
+            const replacements = {
+                async createReplicator(settingOverride: Record<string, unknown> = {}) {
+                    const remoteType = String(settingOverride.remoteType ?? "");
+                    const journalFormat = String(settingOverride.journalFormat ?? "");
+                    state.calls.push({ journalFormat, operation: "create", remoteType });
+                    return {
+                        async inspectJournalStorageConnection(settings: Record<string, unknown>) {
+                            state.calls.push({
+                                journalFormat: String(settings.journalFormat ?? ""),
+                                operation: "inspect",
+                                remoteType: String(settings.remoteType ?? ""),
+                            });
+                            if (state.inspectionMode === "failed") {
+                                return {
+                                    adaptiveCapabilities: {
+                                        byteRange: { status: "not-checked" },
+                                        required: { missing: ["conditional-create"], status: "unsupported" },
+                                    },
+                                    available: false,
+                                    remoteFormat: "empty",
+                                };
+                            }
+                            return {
+                                adaptiveCapabilities: {
+                                    byteRange: { status: "verified" },
+                                    required: { status: "verified" },
+                                },
+                                available: true,
+                                remoteFormat: "empty",
+                            };
+                        },
+                        async tryConnectRemote(settings: Record<string, unknown>) {
+                            state.calls.push({
+                                journalFormat: String(settings.journalFormat ?? ""),
+                                operation: "test",
+                                remoteType: String(settings.remoteType ?? ""),
+                            });
+                            return state.inspectionMode === "verified";
+                        },
+                    };
+                },
+                async askString(title: string, label: string, placeholder: string, isPassword: boolean = false) {
+                    if (title !== "Remote name") return await originalAskString(title, label, placeholder, isPassword);
+                    const name = state.nextProfileName;
+                    state.nextProfileName = "";
+                    if (!name) throw new Error("The remote setup E2E did not supply a profile name");
+                    return name;
+                },
+            };
+            state.unregister = getNewReplicator.addHandler(replacements.createReplicator, -1000, true);
+
+            const confirm = plugin.core.services.UI.confirm;
+            const originalAskString = confirm.askString.bind(confirm);
+            confirm.askString = replacements.askString;
+        }, remoteSetupStateKey);
+    });
+}
+
+export async function setRemoteInspectionMode(port: number, mode: RemoteInspectionMode): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        await page.evaluate(
+            ({ mode, stateKey }) => {
+                const state = (globalThis as RuntimeGlobal)[stateKey as typeof remoteSetupStateKey];
+                if (!state) throw new Error("The remote setup E2E seam is not installed");
+                state.inspectionMode = mode;
+            },
+            { mode, stateKey: remoteSetupStateKey }
+        );
+    });
+}
+
+export async function remoteSetupCalls(port: number): Promise<RemoteSetupCall[]> {
+    return await withObsidianPage(port, async (page) => {
+        return await page.evaluate((stateKey) => {
+            const state = (globalThis as RuntimeGlobal)[stateKey as typeof remoteSetupStateKey];
+            if (!state) throw new Error("The remote setup E2E seam is not installed");
+            return state.calls;
+        }, remoteSetupStateKey);
+    });
+}
+
+export async function openRemoteConfigurationSettings(port: number, timeoutMs: number): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        await page.evaluate(() => {
+            const setting = (globalThis as RuntimeGlobal).app?.setting;
+            if (!setting) throw new Error("Obsidian settings are unavailable");
+            setting.close();
+        });
+        await page.waitForTimeout(100);
+        await page.evaluate(() => {
+            const setting = (globalThis as RuntimeGlobal).app?.setting;
+            if (!setting) throw new Error("Obsidian settings are unavailable");
+            setting.open();
+            setting.openTabById("obsidian-livesync");
+        });
+        const settings = page.locator(".sls-setting");
+        try {
+            await settings.waitFor({ state: "visible", timeout: timeoutMs });
+        } catch (error) {
+            const modalTitles = await page.locator(".modal-title").allTextContents();
+            const settingTabs = await page.locator(".vertical-tab-nav-item").allTextContents();
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(
+                `The LiveSync settings pane did not become visible. Open modal titles: ${JSON.stringify(modalTitles)}. Settings tabs: ${JSON.stringify(settingTabs)}. Cause: ${reason}`
+            );
+        }
+        await settings.locator('.sls-setting-menu-btn[title="Remote Configuration"]').click({ timeout: timeoutMs });
+        await remoteConfigurationPanel(page).waitFor({ state: "visible", timeout: timeoutMs });
+    });
+}
+
+export async function closeRemoteConfigurationSettings(port: number, timeoutMs: number): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        await page.evaluate(() => {
+            const setting = (globalThis as RuntimeGlobal).app?.setting;
+            if (!setting) throw new Error("Obsidian settings are unavailable");
+            setting.close();
+        });
+        await page.locator(".sls-setting").waitFor({ state: "hidden", timeout: timeoutMs });
+    });
+}
+
+export async function beginRemoteProfileSetup(port: number, profileName: string, timeoutMs: number): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        await page.evaluate(
+            ({ profileName, stateKey }) => {
+                const state = (globalThis as RuntimeGlobal)[stateKey as typeof remoteSetupStateKey];
+                if (!state) throw new Error("The remote setup E2E seam is not installed");
+                state.nextProfileName = profileName;
+            },
+            { profileName, stateKey: remoteSetupStateKey }
+        );
+        const add = await tooltipButton(remoteConfigurationPanel(page), "Add new connection", "➕");
+        await add.click({ timeout: timeoutMs });
+        await remoteSelectionModal(page).waitFor({ state: "visible", timeout: timeoutMs });
+    });
+}
+
+export async function captureRemoteProviderChoices(
+    port: number,
+    filename: string,
+    labels: readonly string[],
+    timeoutMs: number
+): Promise<string> {
+    return await captureObsidianDialogue(port, filename, async (page) => {
+        const modal = remoteSelectionModal(page);
+        await modal.waitFor({ state: "visible", timeout: timeoutMs });
+        for (const label of labels) {
+            await modal.getByText(label, { exact: true }).waitFor({ state: "visible", timeout: timeoutMs });
+        }
+    });
+}
+
+export async function selectRemoteProvider(
+    port: number,
+    choiceLabel: string,
+    proceedLabel: string,
+    providerTitle: string,
+    timeoutMs: number
+): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        const selection = remoteSelectionModal(page);
+        await selection
+            .locator("label")
+            .filter({ hasText: choiceLabel })
+            .locator('input[type="radio"]')
+            .first()
+            .check({ timeout: timeoutMs });
+        await selection.getByRole("button", { name: proceedLabel, exact: true }).click({ timeout: timeoutMs });
+        await remoteProviderModal(page, providerTitle).waitFor({ state: "visible", timeout: timeoutMs });
+    });
+}
+
+export async function captureAndCancelRemoteProvider(
+    port: number,
+    filename: string,
+    providerTitle: string,
+    timeoutMs: number
+): Promise<string> {
+    const screenshot = await captureObsidianDialogue(port, filename, async (page) => {
+        await remoteProviderModal(page, providerTitle).waitFor({ state: "visible", timeout: timeoutMs });
+    });
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, providerTitle);
+        await modal.getByRole("button", { name: "Cancel", exact: true }).click({ timeout: timeoutMs });
+        await modal.waitFor({ state: "hidden", timeout: timeoutMs });
+    });
+    return screenshot;
+}
+
+export async function waitForSavedRemoteProfile(port: number, profileName: string, timeoutMs: number): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        await remoteProfileRow(page, profileName).waitFor({ state: "visible", timeout: timeoutMs });
+    });
+}
+
+export async function openSavedRemoteProfile(port: number, profileName: string, timeoutMs: number): Promise<void> {
+    await withObsidianPage(port, async (page) => {
+        const row = remoteProfileRow(page, profileName);
+        await row.waitFor({ state: "visible", timeout: timeoutMs });
+        const configure = await tooltipButton(row, "Configure", "🔧");
+        await configure.click({ timeout: timeoutMs });
+    });
+}
+
+export async function runtimeRemoteSettings(port: number): Promise<RuntimeSettings> {
+    return await withObsidianPage(port, async (page) => {
+        return await page.evaluate(() => {
+            const plugin = (globalThis as RuntimeGlobal).app?.plugins?.plugins["obsidian-livesync"];
+            if (!plugin) throw new Error("Self-hosted LiveSync is not loaded");
+            return structuredClone(plugin.core.services.setting.currentSettings());
+        });
+    });
+}

test/e2e-obsidian/runner/setupUri.ts

@@ -21,6 +21,7 @@ export type SetupState = {
     p2pEnabled: boolean;
     p2pRelays: string;
     p2pRoomId: string;
+    postgrestActiveConnectionURI: string;
 };
 
 export type SetupCaptureNames = {
@@ -182,16 +183,16 @@ export async function captureAndStartInitialisation(
         ? "Setup Complete: Preparing This P2P Device"
         : p2pAdditionalDevice
           ? "Setup Complete: Preparing to Fetch from Another Device"
-        : mode === "new"
-          ? "Setup Complete: Preparing to Initialise Server"
-          : "Setup Complete: Preparing to Fetch Synchronisation Data";
+          : mode === "new"
+            ? "Setup Complete: Preparing to Initialise Server"
+            : "Setup Complete: Preparing to Fetch Synchronisation Data";
     const button = p2pFirstDevice
         ? "Restart and Prepare This Device"
         : p2pAdditionalDevice
           ? "Restart and Select Source Device"
-        : mode === "new"
-          ? "Restart and Initialise Server"
-          : "Restart and Fetch Data";
+          : mode === "new"
+            ? "Restart and Initialise Server"
+            : "Restart and Fetch Data";
     if (p2pAdditionalDevice) {
         await withObsidianPage(port, async (page) => {
             const modal = modalByTitle(page, title);
@@ -345,6 +346,7 @@ export async function readSetupState(cliBinary: string, environment: NodeJS.Proc
             "p2pEnabled:settings.P2P_Enabled===true,",
             "p2pRelays:settings.P2P_relays||'',",
             "p2pRoomId:settings.P2P_roomID||'',",
+            "postgrestActiveConnectionURI:settings.postgrestActiveConnectionURI||'',",
             "});",
             "})()",
         ].join(""),

test/e2e-obsidian/scripts/adaptive-postgrest.ts

@@ -0,0 +1,262 @@
+/**
+ * Exercises the Adaptive-only PostgREST Journal provider through visible,
+ * safety-gated onboarding. The shared Adaptive Journal runner owns restart
+ * persistence, device-generated Setup URI transfer, Fast Fetch, and a
+ * two-device text and binary return journey.
+ */
+import { parsePostgRESTConnectionURI } from "@vrtmrz/livesync-commonlib/journal-storage";
+import { runAdaptiveJournalObsidianRoundTrip, runNpmScript } from "../runner/adaptiveJournal.ts";
+import { assertEqual } from "../runner/liveSyncWorkflow.ts";
+import { captureGuideDialogue, modalByTitle, selectRadioOption, type SetupState } from "../runner/setupUri.ts";
+import { withObsidianPage } from "../runner/ui.ts";
+
+type PostgRESTConfig = {
+    apiKey: string;
+    endpoint: string;
+    schema: string;
+    vaultCredential: string;
+    vaultId: string;
+};
+
+const supportedArguments = new Set(["--keep-postgrest", "--manage-postgrest"]);
+const unsupportedArguments = process.argv.slice(2).filter((argument) => !supportedArguments.has(argument));
+if (unsupportedArguments.length > 0) {
+    throw new Error(`Unsupported Adaptive PostgREST argument: ${unsupportedArguments.join(", ")}`);
+}
+
+const managePostgREST = process.argv.includes("--manage-postgrest");
+const keepPostgRESTFixture = process.argv.includes("--keep-postgrest");
+const uiTimeoutMs = Number(process.env.E2E_OBSIDIAN_SETUP_URI_TIMEOUT_MS ?? 30000);
+
+function environmentValue(primary: string, legacy: string, fallback: string): string {
+    return process.env[primary] ?? process.env[legacy] ?? fallback;
+}
+
+function loadPostgRESTConfig(): PostgRESTConfig {
+    const endpoint = environmentValue("POSTGREST_ENDPOINT", "postgrestEndpoint", "http://127.0.0.1:3001").replace(
+        /\/+$/u,
+        ""
+    );
+    const endpointUrl = new URL(endpoint);
+    if (
+        (endpointUrl.protocol !== "http:" && endpointUrl.protocol !== "https:") ||
+        endpointUrl.username !== "" ||
+        endpointUrl.password !== "" ||
+        endpointUrl.search !== "" ||
+        endpointUrl.hash !== ""
+    ) {
+        throw new Error("Adaptive PostgREST requires a complete HTTP or HTTPS endpoint without embedded credentials.");
+    }
+    const config = {
+        apiKey: environmentValue("POSTGREST_API_KEY", "postgrestApiKey", ""),
+        endpoint,
+        schema: environmentValue("POSTGREST_SCHEMA", "postgrestSchema", "livesync_api"),
+        vaultCredential: environmentValue(
+            "POSTGREST_VAULT_CREDENTIAL",
+            "postgrestVaultCredential",
+            "adaptive-cli-vault-credential-0000000000001"
+        ),
+        vaultId: environmentValue("POSTGREST_VAULT_ID", "postgrestVaultId", "adaptive-cli-vault-01"),
+    };
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(config.schema)) {
+        throw new Error("Adaptive PostgREST requires a valid exposed schema identifier.");
+    }
+    if (!/^[A-Za-z0-9_-]{16,128}$/u.test(config.vaultId) || config.vaultCredential.length === 0) {
+        throw new Error("Adaptive PostgREST requires a provisioned Vault ID and Vault credential.");
+    }
+    return config;
+}
+
+function postgRESTHeaders(config: PostgRESTConfig): Headers {
+    const headers = new Headers({
+        Accept: "application/json",
+        "Accept-Profile": config.schema,
+        "Content-Profile": config.schema,
+        "X-LiveSync-Vault-Credential": config.vaultCredential,
+        "X-LiveSync-Vault-ID": config.vaultId,
+    });
+    if (config.apiKey) headers.set("apikey", config.apiKey);
+    return headers;
+}
+
+async function readEstimatedSize(config: PostgRESTConfig): Promise<number> {
+    const response = await fetch(`${config.endpoint}/rpc/livesync_adaptive_status`, {
+        headers: postgRESTHeaders(config),
+        method: "GET",
+        signal: AbortSignal.timeout(5000),
+    });
+    if (!response.ok) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new Error(`Adaptive PostgREST status failed with HTTP ${response.status}.`);
+    }
+    const value = (await response.json()) as unknown;
+    const body = Array.isArray(value) && value.length === 1 ? value[0] : value;
+    const estimatedSize = Number(
+        body && typeof body === "object" && !Array.isArray(body)
+            ? (body as { estimated_size?: unknown }).estimated_size
+            : Number.NaN
+    );
+    if (!Number.isFinite(estimatedSize) || estimatedSize < 0) {
+        throw new Error("Adaptive PostgREST status returned an invalid estimated size.");
+    }
+    return estimatedSize;
+}
+
+async function assertPostgRESTReachable(config: PostgRESTConfig): Promise<void> {
+    await readEstimatedSize(config);
+}
+
+async function enterManualAdaptivePostgRESTSettings(
+    port: number,
+    config: PostgRESTConfig,
+    vaultPassphrase: string
+): Promise<string[]> {
+    const screenshots: string[] = [];
+    await withObsidianPage(port, async (page) => {
+        const invitation = page.locator(".notice").filter({ hasText: "Welcome to Self-hosted LiveSync" });
+        await invitation.waitFor({ state: "visible", timeout: uiTimeoutMs });
+        await invitation.locator(".sls-onboarding-invitation-action").click({ timeout: uiTimeoutMs });
+
+        const intro = modalByTitle(page, "Welcome to Self-hosted LiveSync");
+        await intro.waitFor({ state: "visible", timeout: uiTimeoutMs });
+        await selectRadioOption(intro, "I am setting this up for the first time");
+        await intro
+            .getByRole("button", { name: "Yes, I want to set up a new synchronisation" })
+            .click({ timeout: uiTimeoutMs });
+
+        const method = modalByTitle(page, "Connection Method");
+        await method.waitFor({ state: "visible", timeout: uiTimeoutMs });
+        await selectRadioOption(method, "Configure a remote manually");
+        await method.getByRole("button", { name: "Proceed with manual configuration" }).click({ timeout: uiTimeoutMs });
+
+        const encryption = modalByTitle(page, "End-to-End Encryption");
+        await encryption.waitFor({ state: "visible", timeout: uiTimeoutMs });
+        await encryption
+            .locator("label.row")
+            .filter({ hasText: "End-to-End Encryption" })
+            .locator('input[type="checkbox"]')
+            .first()
+            .check({ timeout: uiTimeoutMs });
+        await encryption.locator('input[name="e2ee-passphrase"]').fill(vaultPassphrase);
+    });
+    screenshots.push(
+        await captureGuideDialogue(port, "guide-adaptive-postgrest-encryption.png", "End-to-End Encryption")
+    );
+
+    await withObsidianPage(port, async (page) => {
+        await modalByTitle(page, "End-to-End Encryption")
+            .getByRole("button", { name: "Proceed", exact: true })
+            .click({ timeout: uiTimeoutMs });
+
+        const remoteSelection = modalByTitle(page, "Choose a synchronisation remote");
+        await remoteSelection.waitFor({ state: "visible", timeout: uiTimeoutMs });
+        await selectRadioOption(remoteSelection, "PostgREST Journal");
+        await remoteSelection
+            .getByRole("button", { name: "Continue to PostgREST setup", exact: true })
+            .click({ timeout: uiTimeoutMs });
+
+        const postgRESTModal = modalByTitle(page, "PostgREST Journal Configuration");
+        await postgRESTModal.waitFor({ state: "visible", timeout: uiTimeoutMs });
+        await postgRESTModal.locator('input[name="postgrest-endpoint"]').fill(config.endpoint);
+        await postgRESTModal.locator('input[name="postgrest-vault-id"]').fill(config.vaultId);
+        await postgRESTModal.locator('input[name="postgrest-vault-credential"]').fill(config.vaultCredential);
+        await postgRESTModal.locator('input[name="postgrest-schema"]').fill(config.schema);
+        if (config.apiKey) await postgRESTModal.locator('input[name="postgrest-api-key"]').fill(config.apiKey);
+        await postgRESTModal.locator('input[name="postgrest-use-internal-api"]').check({ timeout: uiTimeoutMs });
+
+        if (
+            (await postgRESTModal.locator('select[name="postgrest-journal-format"]').count()) !== 0 ||
+            (await postgRESTModal.locator('select[name="postgrest-pack-read-policy"]').count()) !== 0
+        ) {
+            throw new Error("Adaptive-only PostgREST onboarding exposed an Opaque or Pack retrieval choice.");
+        }
+        if (
+            (await postgRESTModal
+                .getByRole("button", { name: "Continue with verified settings", exact: true })
+                .count()) !== 0
+        ) {
+            throw new Error("Adaptive PostgREST could continue before its server safety check completed.");
+        }
+        await postgRESTModal
+            .getByRole("button", { name: "Check PostgREST server", exact: true })
+            .click({ timeout: uiTimeoutMs });
+        await postgRESTModal
+            .getByText("The required PostgREST RPC operations and binary semantics were verified.", { exact: false })
+            .waitFor({ state: "visible", timeout: uiTimeoutMs });
+        await postgRESTModal
+            .getByRole("button", { name: "Continue with verified settings", exact: true })
+            .waitFor({ state: "visible", timeout: uiTimeoutMs });
+        if (
+            (await postgRESTModal.getByRole("button", { name: "Save without connecting", exact: true }).count()) !== 0
+        ) {
+            throw new Error("Adaptive PostgREST onboarding exposed the unverified Settings-only save action.");
+        }
+    });
+    screenshots.push(
+        await captureGuideDialogue(port, "guide-adaptive-postgrest-safety-check.png", "PostgREST Journal Configuration")
+    );
+    await withObsidianPage(port, async (page) => {
+        const postgRESTModal = modalByTitle(page, "PostgREST Journal Configuration");
+        await postgRESTModal
+            .getByRole("button", { name: "Continue with verified settings", exact: true })
+            .click({ timeout: uiTimeoutMs });
+        await modalByTitle(page, "Setup Complete: Preparing to Initialise Server").waitFor({
+            state: "visible",
+            timeout: uiTimeoutMs,
+        });
+    });
+    return screenshots;
+}
+
+function assertAdaptivePostgRESTSettings(state: SetupState, config: PostgRESTConfig, label: string): void {
+    assertEqual(state.remoteType, "POSTGREST", `${label} did not retain PostgREST as its active remote.`);
+    assertEqual(state.journalFormat, "adaptive-v1", `${label} did not retain the Adaptive Journal format.`);
+    assertEqual(state.packReadPolicy, "whole-pack", `${label} did not retain complete Pack retrieval.`);
+    assertEqual(state.remoteConfigurationCount, 1, `${label} did not retain exactly one remote profile.`);
+    const connection = parsePostgRESTConnectionURI(state.postgrestActiveConnectionURI);
+    assertEqual(connection.endpoint, config.endpoint, `${label} retained a different PostgREST endpoint.`);
+    assertEqual(connection.schema, config.schema, `${label} retained a different PostgREST schema.`);
+    if (connection.vaultId !== config.vaultId || connection.vaultCredential !== config.vaultCredential) {
+        throw new Error(`${label} did not retain the provisioned PostgREST Vault ID and Vault credential.`);
+    }
+    if (connection.apiKey !== config.apiKey) {
+        throw new Error(`${label} did not retain the configured PostgREST client API key.`);
+    }
+    assertEqual(
+        connection.useCustomRequestHandler,
+        true,
+        `${label} did not retain the Obsidian internal request API selection.`
+    );
+}
+
+async function main(): Promise<void> {
+    const config = loadPostgRESTConfig();
+    let shouldStopPostgREST = false;
+
+    try {
+        if (managePostgREST) {
+            await runNpmScript("test:docker-postgrest:start");
+            shouldStopPostgREST = !keepPostgRESTFixture;
+        }
+        await assertPostgRESTReachable(config);
+        await runAdaptiveJournalObsidianRoundTrip({
+            label: "Adaptive PostgREST",
+            slug: "adaptive-postgrest",
+            targetDescription: `Temporary PostgREST target: ${config.endpoint}`,
+            enterManualSettings: async (port, vaultPassphrase) =>
+                await enterManualAdaptivePostgRESTSettings(port, config, vaultPassphrase),
+            assertSettings: (state, label) => assertAdaptivePostgRESTSettings(state, config, label),
+        });
+    } finally {
+        if (shouldStopPostgREST) {
+            await runNpmScript("test:docker-postgrest:stop").catch((error: unknown) => {
+                console.warn(error instanceof Error ? error.message : error);
+            });
+        }
+    }
+}
+
+main().catch((error: unknown) => {
+    console.error(error instanceof Error ? error.stack : error);
+    process.exit(1);
+});

test/e2e-obsidian/scripts/local-suite.ts

@@ -17,6 +17,7 @@ const testSteps: Step[] = [
     { name: "Svelte dialogue mounts", args: ["run", "test:e2e:obsidian:dialog-mounts"] },
     { name: "revision repair", args: ["run", "test:e2e:obsidian:revision-repair"] },
     { name: "settings UI", args: ["run", "test:e2e:obsidian:settings-ui"] },
+    { name: "remote setup providers", args: ["run", "test:e2e:obsidian:remote-setup-providers"] },
     { name: "Review Harness", args: ["run", "test:e2e:obsidian:review-harness"] },
     { name: "P2P status pane", args: ["run", "test:e2e:obsidian:p2p-pane"] },
     { name: "vault reflection", args: ["run", "test:e2e:obsidian:vault-reflection"] },
@@ -30,6 +31,7 @@ const testSteps: Step[] = [
         args: ["run", "test:e2e:obsidian:cli-to-obsidian-sync"],
     },
     { name: "Object Storage upload", args: ["run", "test:e2e:obsidian:minio-upload"] },
+    { name: "Adaptive PostgREST workflow", args: ["run", "test:e2e:obsidian:adaptive-postgrest"] },
     {
         name: "Object Storage Setup URI workflow",
         args: ["run", "test:e2e:obsidian:object-storage-setup-uri-workflow"],
@@ -46,10 +48,12 @@ const testSteps: Step[] = [
 const manageCouchDb = process.argv.includes("--manage-couchdb") || process.argv.includes("--manage-services");
 const manageMinio = process.argv.includes("--manage-minio") || process.argv.includes("--manage-services");
 const manageP2P = process.argv.includes("--manage-p2p") || process.argv.includes("--manage-services");
+const managePostgREST = process.argv.includes("--manage-postgrest") || process.argv.includes("--manage-services");
 const keepServices = process.argv.includes("--keep-services");
 const keepCouchDb = keepServices || process.argv.includes("--keep-couchdb");
 const keepMinio = keepServices || process.argv.includes("--keep-minio");
 const keepP2P = keepServices || process.argv.includes("--keep-p2p");
+const keepPostgREST = keepServices || process.argv.includes("--keep-postgrest");
 
 function npmBinary(): string {
     return process.platform === "win32" ? "npm.cmd" : "npm";
@@ -104,10 +108,18 @@ async function stopManagedP2P(): Promise<void> {
     });
 }
 
+async function stopManagedPostgREST(): Promise<void> {
+    await runStep({
+        name: "stop PostgREST fixture",
+        args: ["run", "test:docker-postgrest:stop"],
+        optional: true,
+    });
+}
 async function main(): Promise<void> {
     let shouldStopCouchDb = false;
     let shouldStopMinio = false;
     let shouldStopP2P = false;
+    let shouldStopPostgREST = false;
     try {
         if (manageCouchDb) {
             await stopManagedCouchDb();
@@ -124,11 +136,19 @@ async function main(): Promise<void> {
             await runStep({ name: "start P2P relay fixture", args: ["run", "test:docker-p2p:start"] });
             shouldStopP2P = !keepP2P;
         }
+        if (managePostgREST) {
+            await stopManagedPostgREST();
+            await runStep({ name: "start PostgREST fixture", args: ["run", "test:docker-postgrest:start"] });
+            shouldStopPostgREST = !keepPostgREST;
+        }
 
         for (const step of testSteps) {
             await runStep(step);
         }
     } finally {
+        if (shouldStopPostgREST) {
+            await stopManagedPostgREST();
+        }
         if (shouldStopP2P) {
             await stopManagedP2P();
         }

test/e2e-obsidian/scripts/remote-setup-providers.ts

@@ -0,0 +1,524 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import {
+    defaultRemoteProviderRegistry,
+    type BuiltInRemoteConfiguration,
+    type RemoteConfiguration,
+} from "@vrtmrz/livesync-commonlib/remote-configurations";
+import { parsePostgRESTConnectionURI, parseWebDAVConnectionURI } from "@vrtmrz/livesync-commonlib/journal-storage";
+import { enableAndReloadPlugin } from "@vrtmrz/obsidian-test-session";
+import type { Locator, Page } from "playwright";
+import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
+import {
+    createE2eCouchDbPluginData,
+    createE2eObsidianDeviceLocalState,
+    waitForLiveSyncCoreReady,
+} from "../runner/liveSyncWorkflow.ts";
+import {
+    beginRemoteProfileSetup,
+    captureAndCancelRemoteProvider,
+    captureRemoteProviderChoices,
+    closeRemoteConfigurationSettings,
+    installRemoteSetupTestSeam,
+    openRemoteConfigurationSettings,
+    openSavedRemoteProfile,
+    remoteProviderModal,
+    remoteSetupCalls,
+    runtimeRemoteSettings,
+    selectRemoteProvider,
+    setRemoteInspectionMode,
+    waitForSavedRemoteProfile,
+} from "../runner/remoteSetupUi.ts";
+import { startObsidianLiveSyncSession, type ObsidianLiveSyncSession } from "../runner/session.ts";
+import {
+    captureObsidianDialogue,
+    captureObsidianElement,
+    obsidianRemoteDebuggingPort,
+    withObsidianPage,
+} from "../runner/ui.ts";
+import { createTemporaryVault } from "../runner/vault.ts";
+
+const uiTimeoutMs = Number(process.env.E2E_OBSIDIAN_REMOTE_SETUP_TIMEOUT_MS ?? 10000);
+const repositoryA = "A".repeat(43);
+const repositoryB = `${"A".repeat(42)}Q`;
+
+const profiles = {
+    postgrest: {
+        apiKey: "publishable-ui-key",
+        credential: "remote-setup-ui-credential",
+        endpoint: "https://postgrest.example.test/rest/v1",
+        expectedRepositoryId: repositoryB,
+        name: "PostgREST UI profile",
+        schema: "livesync_api",
+        vaultId: "remote-setup-vault-01",
+    },
+    s3: {
+        accessKey: "remote-setup-access-key",
+        bucket: "remote-setup-bucket",
+        endpoint: "https://s3.example.test",
+        name: "S3 UI profile",
+        prefix: "adaptive-ui/",
+        region: "us-east-1",
+        secretKey: "remote-setup-secret-key",
+    },
+    webdav: {
+        endpoint: "https://dav.example.test/remote.php/dav/files/tester",
+        expectedRepositoryId: repositoryA,
+        name: "WebDAV UI profile",
+        password: "remote-setup-password",
+        prefix: "adaptive-ui/",
+        username: "remote-setup-user",
+    },
+} as const;
+
+const providerChoices = [
+    "CouchDB",
+    "S3-compatible Object Storage",
+    "WebDAV Journal",
+    "PostgREST Journal",
+    "Peer-to-Peer (P2P)",
+] as const;
+
+type PersistedSettings = {
+    activeConfigurationId: string;
+    remoteConfigurations: Record<string, RemoteConfiguration>;
+};
+
+function assertEqual(actual: unknown, expected: unknown, message: string): void {
+    if (actual !== expected) {
+        throw new Error(`${message}\nExpected: ${String(expected)}\nActual: ${String(actual)}`);
+    }
+}
+
+function profileByName(settings: PersistedSettings, name: string): RemoteConfiguration {
+    const profile = Object.values(settings.remoteConfigurations).find((candidate) => candidate.name === name);
+    if (!profile) throw new Error(`Saved remote profile '${name}' was not found`);
+    return profile;
+}
+
+function parseProfile(settings: PersistedSettings, name: string): BuiltInRemoteConfiguration {
+    return defaultRemoteProviderRegistry.parse(profileByName(settings, name).uri);
+}
+
+function assertPersistedProfiles(settings: PersistedSettings): void {
+    const s3 = parseProfile(settings, profiles.s3.name);
+    assertEqual(s3.type, "s3", "The S3 dialogue returned the wrong provider type.");
+    if (s3.type !== "s3") return;
+    assertEqual(s3.settings.endpoint, profiles.s3.endpoint, "The S3 endpoint was not saved.");
+    assertEqual(s3.settings.bucket, profiles.s3.bucket, "The S3 bucket was not saved.");
+    assertEqual(s3.settings.bucketPrefix, profiles.s3.prefix, "The S3 prefix was not saved.");
+    assertEqual(s3.settings.journalFormat, "adaptive-v1", "The S3 Adaptive format was not saved.");
+    assertEqual(s3.settings.packReadPolicy, "range", "The S3 Range policy was not saved.");
+
+    const webdav = parseProfile(settings, profiles.webdav.name);
+    assertEqual(webdav.type, "webdav", "The WebDAV dialogue returned the wrong provider type.");
+    if (webdav.type !== "webdav") return;
+    const webdavConnection = parseWebDAVConnectionURI(webdav.settings.webDAVactiveConnectionURI);
+    assertEqual(webdavConnection.endpoint, profiles.webdav.endpoint, "The WebDAV endpoint was not saved.");
+    assertEqual(webdavConnection.prefix, profiles.webdav.prefix, "The WebDAV prefix was not saved.");
+    assertEqual(webdavConnection.username, profiles.webdav.username, "The WebDAV username was not saved.");
+    assertEqual(webdav.settings.expectedRepositoryId, repositoryA, "The WebDAV repository ID was not saved.");
+    assertEqual(webdav.settings.journalFormat, "adaptive-v1", "The WebDAV Adaptive format was not saved.");
+    assertEqual(webdav.settings.packReadPolicy, "range", "The WebDAV Range policy was not saved.");
+
+    const postgrest = parseProfile(settings, profiles.postgrest.name);
+    assertEqual(postgrest.type, "postgrest", "The PostgREST dialogue returned the wrong provider type.");
+    if (postgrest.type !== "postgrest") return;
+    const postgrestConnection = parsePostgRESTConnectionURI(postgrest.settings.postgrestActiveConnectionURI);
+    assertEqual(postgrestConnection.endpoint, profiles.postgrest.endpoint, "The PostgREST endpoint was not saved.");
+    assertEqual(postgrestConnection.schema, profiles.postgrest.schema, "The PostgREST schema was not saved.");
+    assertEqual(postgrestConnection.vaultId, profiles.postgrest.vaultId, "The PostgREST Vault ID was not saved.");
+    assertEqual(postgrest.settings.expectedRepositoryId, repositoryB, "The PostgREST repository ID was not saved.");
+    assertEqual(postgrest.settings.journalFormat, "adaptive-v1", "PostgREST did not retain its fixed format.");
+    assertEqual(postgrest.settings.packReadPolicy, "whole-pack", "PostgREST did not retain its fixed read policy.");
+}
+
+function assertEncryptedProfilesAtRest(settings: PersistedSettings): void {
+    for (const fixture of [profiles.s3, profiles.webdav, profiles.postgrest]) {
+        const profile = profileByName(settings, fixture.name);
+        assertEqual(profile.isEncrypted, true, `Saved remote profile '${fixture.name}' was not encrypted at rest.`);
+        for (const exposed of [
+            profiles.s3.endpoint,
+            profiles.s3.secretKey,
+            profiles.webdav.endpoint,
+            profiles.webdav.password,
+            profiles.postgrest.endpoint,
+            profiles.postgrest.credential,
+        ]) {
+            if (profile.uri.includes(exposed)) {
+                throw new Error(`Saved remote profile '${fixture.name}' exposed a connection secret or endpoint.`);
+            }
+        }
+    }
+}
+
+async function fill(locator: Locator, value: string): Promise<void> {
+    await locator.fill(value, { timeout: uiTimeoutMs });
+}
+
+async function openAdvanced(modal: Locator): Promise<void> {
+    const details = modal.locator("details").filter({ hasText: "Advanced Settings" }).first();
+    await details.waitFor({ state: "visible", timeout: uiTimeoutMs });
+    if (!(await details.getAttribute("open"))) {
+        await details.locator("summary").click({ timeout: uiTimeoutMs });
+    }
+}
+
+async function expectInputValue(modal: Locator, name: string, expected: string): Promise<void> {
+    const actual = await modal.locator(`[name="${name}"]`).inputValue({ timeout: uiTimeoutMs });
+    assertEqual(actual, expected, `Reloaded control '${name}' has the wrong value.`);
+}
+
+async function mountLegacyProvider(
+    port: number,
+    profileName: string,
+    choice: string,
+    proceed: string,
+    title: string,
+    screenshotName: string
+): Promise<string> {
+    await beginRemoteProfileSetup(port, profileName, uiTimeoutMs);
+    await selectRemoteProvider(port, choice, proceed, title, uiTimeoutMs);
+    return await captureAndCancelRemoteProvider(port, screenshotName, title, uiTimeoutMs);
+}
+
+async function addS3Profile(port: number): Promise<string> {
+    await beginRemoteProfileSetup(port, profiles.s3.name, uiTimeoutMs);
+    await selectRemoteProvider(
+        port,
+        "S3-compatible Object Storage",
+        "Continue to Object Storage setup",
+        "S3/MinIO/R2 Configuration",
+        uiTimeoutMs
+    );
+    const screenshot = await captureObsidianDialogue(port, "remote-setup-s3-adaptive.png", async (page) => {
+        const modal = remoteProviderModal(page, "S3/MinIO/R2 Configuration");
+        const testButton = modal.getByRole("button", { name: "Test Settings and Continue", exact: true });
+        if (!(await testButton.isDisabled()))
+            throw new Error("Incomplete S3 settings did not disable connection testing.");
+        await fill(modal.locator('[name="s3-endpoint"]'), profiles.s3.endpoint);
+        await fill(modal.locator('[name="s3-access-key-id"]'), profiles.s3.accessKey);
+        await fill(modal.locator('[name="s3-secret-access-key"]'), profiles.s3.secretKey);
+        await fill(modal.locator('[name="s3-bucket-name"]'), profiles.s3.bucket);
+        await fill(modal.locator('[name="s3-region"]'), profiles.s3.region);
+        await fill(modal.locator('[name="s3-folder-prefix"]'), profiles.s3.prefix);
+        await openAdvanced(modal);
+        await modal.locator('[name="s3-journal-format"]').selectOption("adaptive-v1");
+        await modal.locator('[name="s3-pack-read-policy"]').selectOption("range");
+        if (await testButton.isDisabled()) throw new Error("Complete S3 settings did not enable connection testing.");
+    });
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "S3/MinIO/R2 Configuration");
+        await modal.getByRole("button", { name: "Test Settings and Continue", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
+        await modal.waitFor({ state: "hidden", timeout: uiTimeoutMs });
+    });
+    await waitForSavedRemoteProfile(port, profiles.s3.name, uiTimeoutMs);
+    return screenshot;
+}
+
+async function addWebDAVProfile(port: number): Promise<string> {
+    await beginRemoteProfileSetup(port, profiles.webdav.name, uiTimeoutMs);
+    await selectRemoteProvider(
+        port,
+        "WebDAV Journal",
+        "Continue to WebDAV setup",
+        "WebDAV Journal Configuration",
+        uiTimeoutMs
+    );
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "WebDAV Journal Configuration");
+        await fill(modal.locator('[name="webdav-endpoint"]'), profiles.webdav.endpoint);
+        await fill(modal.locator('[name="webdav-username"]'), profiles.webdav.username);
+        await fill(modal.locator('[name="webdav-password"]'), profiles.webdav.password);
+        await fill(modal.locator('[name="webdav-prefix"]'), profiles.webdav.prefix);
+        await modal.locator('[name="webdav-use-internal-api"]').check({ timeout: uiTimeoutMs });
+        await openAdvanced(modal);
+        await modal.locator('[name="webdav-journal-format"]').selectOption("adaptive-v1");
+        await fill(modal.locator('[name="webdav-expected-repository-id"]'), repositoryA);
+        await modal.locator('[name="webdav-pack-read-policy"]').selectOption("range");
+    });
+
+    await setRemoteInspectionMode(port, "failed");
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "WebDAV Journal Configuration");
+        await modal.getByRole("button", { name: "Run endpoint safety check", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
+        await modal.getByText("missing required Adaptive operations", { exact: false }).waitFor({
+            state: "visible",
+            timeout: uiTimeoutMs,
+        });
+        if ((await modal.getByRole("button", { name: "Save verified settings", exact: true }).count()) !== 0) {
+            throw new Error("A failed WebDAV safety check exposed the verified-save action.");
+        }
+    });
+
+    await setRemoteInspectionMode(port, "verified");
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "WebDAV Journal Configuration");
+        await modal.getByRole("button", { name: "Run endpoint safety check", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
+        await modal.getByRole("button", { name: "Save verified settings", exact: true }).waitFor({
+            state: "visible",
+            timeout: uiTimeoutMs,
+        });
+        await fill(modal.locator('[name="webdav-prefix"]'), "stale-inspection/");
+        if ((await modal.getByRole("button", { name: "Save verified settings", exact: true }).count()) !== 0) {
+            throw new Error("Editing WebDAV settings did not invalidate the previous safety check.");
+        }
+        await fill(modal.locator('[name="webdav-prefix"]'), profiles.webdav.prefix);
+        await modal.getByRole("button", { name: "Run endpoint safety check", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
+        await modal.getByRole("button", { name: "Save verified settings", exact: true }).waitFor({
+            state: "visible",
+            timeout: uiTimeoutMs,
+        });
+    });
+    const screenshot = await captureObsidianDialogue(port, "remote-setup-webdav-verified.png", async (page) => {
+        await remoteProviderModal(page, "WebDAV Journal Configuration")
+            .getByText("Required Adaptive operations are supported", { exact: false })
+            .waitFor({ state: "visible", timeout: uiTimeoutMs });
+    });
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "WebDAV Journal Configuration");
+        await modal.getByRole("button", { name: "Save verified settings", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
+        await modal.waitFor({ state: "hidden", timeout: uiTimeoutMs });
+    });
+    await waitForSavedRemoteProfile(port, profiles.webdav.name, uiTimeoutMs);
+    return screenshot;
+}
+
+async function addPostgRESTProfile(port: number): Promise<string> {
+    await beginRemoteProfileSetup(port, profiles.postgrest.name, uiTimeoutMs);
+    await selectRemoteProvider(
+        port,
+        "PostgREST Journal",
+        "Continue to PostgREST setup",
+        "PostgREST Journal Configuration",
+        uiTimeoutMs
+    );
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "PostgREST Journal Configuration");
+        const check = modal.getByRole("button", { name: "Check PostgREST server", exact: true });
+        if (!(await check.isDisabled())) {
+            throw new Error("Incomplete PostgREST settings did not disable the server check.");
+        }
+        await fill(modal.locator('[name="postgrest-endpoint"]'), profiles.postgrest.endpoint);
+        await fill(modal.locator('[name="postgrest-vault-id"]'), profiles.postgrest.vaultId);
+        await fill(modal.locator('[name="postgrest-vault-credential"]'), profiles.postgrest.credential);
+        await fill(modal.locator('[name="postgrest-schema"]'), profiles.postgrest.schema);
+        await fill(modal.locator('[name="postgrest-api-key"]'), profiles.postgrest.apiKey);
+        await modal.locator('[name="postgrest-use-internal-api"]').check({ timeout: uiTimeoutMs });
+        await openAdvanced(modal);
+        await fill(modal.locator('[name="postgrest-expected-repository-id"]'), repositoryB);
+        if (await check.isDisabled()) throw new Error("Complete PostgREST settings did not enable the server check.");
+        await check.click({ timeout: uiTimeoutMs });
+        try {
+            await modal.getByRole("button", { name: "Save verified settings", exact: true }).waitFor({
+                state: "visible",
+                timeout: uiTimeoutMs,
+            });
+        } catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(
+                `PostgREST verification did not enable saving. Dialogue text:\n${await modal.innerText()}\nCause: ${reason}`
+            );
+        }
+        await fill(modal.locator('[name="postgrest-api-key"]'), "stale-publishable-key");
+        if ((await modal.getByRole("button", { name: "Save verified settings", exact: true }).count()) !== 0) {
+            throw new Error("Editing PostgREST settings did not invalidate the previous server check.");
+        }
+        await fill(modal.locator('[name="postgrest-api-key"]'), profiles.postgrest.apiKey);
+        await modal.getByRole("button", { name: "Check PostgREST server", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
+        await modal.getByRole("button", { name: "Save verified settings", exact: true }).waitFor({
+            state: "visible",
+            timeout: uiTimeoutMs,
+        });
+    });
+    const screenshot = await captureObsidianDialogue(port, "remote-setup-postgrest-verified.png", async (page) => {
+        await remoteProviderModal(page, "PostgREST Journal Configuration")
+            .getByText("required PostgREST RPC operations", { exact: false })
+            .waitFor({ state: "visible", timeout: uiTimeoutMs });
+    });
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "PostgREST Journal Configuration");
+        await modal.getByRole("button", { name: "Save verified settings", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
+        await modal.waitFor({ state: "hidden", timeout: uiTimeoutMs });
+    });
+    await waitForSavedRemoteProfile(port, profiles.postgrest.name, uiTimeoutMs);
+    return screenshot;
+}
+
+async function assertReloadedS3(port: number): Promise<void> {
+    await openSavedRemoteProfile(port, profiles.s3.name, uiTimeoutMs);
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "S3/MinIO/R2 Configuration");
+        await expectInputValue(modal, "s3-endpoint", profiles.s3.endpoint);
+        await expectInputValue(modal, "s3-bucket-name", profiles.s3.bucket);
+        await openAdvanced(modal);
+        await expectInputValue(modal, "s3-journal-format", "adaptive-v1");
+        await expectInputValue(modal, "s3-pack-read-policy", "range");
+        await modal.getByRole("button", { name: "Cancel", exact: true }).click({ timeout: uiTimeoutMs });
+        await modal.waitFor({ state: "hidden", timeout: uiTimeoutMs });
+    });
+}
+
+async function assertReloadedWebDAV(port: number): Promise<void> {
+    await openSavedRemoteProfile(port, profiles.webdav.name, uiTimeoutMs);
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "WebDAV Journal Configuration");
+        await expectInputValue(modal, "webdav-endpoint", profiles.webdav.endpoint);
+        await expectInputValue(modal, "webdav-prefix", profiles.webdav.prefix);
+        await openAdvanced(modal);
+        await expectInputValue(modal, "webdav-journal-format", "adaptive-v1");
+        await expectInputValue(modal, "webdav-expected-repository-id", repositoryA);
+        await expectInputValue(modal, "webdav-pack-read-policy", "range");
+        await modal.getByRole("button", { name: "Cancel", exact: true }).click({ timeout: uiTimeoutMs });
+        await modal.waitFor({ state: "hidden", timeout: uiTimeoutMs });
+    });
+}
+
+async function assertReloadedPostgREST(port: number): Promise<void> {
+    await openSavedRemoteProfile(port, profiles.postgrest.name, uiTimeoutMs);
+    await withObsidianPage(port, async (page) => {
+        const modal = remoteProviderModal(page, "PostgREST Journal Configuration");
+        await expectInputValue(modal, "postgrest-endpoint", profiles.postgrest.endpoint);
+        await expectInputValue(modal, "postgrest-vault-id", profiles.postgrest.vaultId);
+        await expectInputValue(modal, "postgrest-schema", profiles.postgrest.schema);
+        await openAdvanced(modal);
+        await expectInputValue(modal, "postgrest-expected-repository-id", repositoryB);
+        await modal.getByRole("button", { name: "Cancel", exact: true }).click({ timeout: uiTimeoutMs });
+        await modal.waitFor({ state: "hidden", timeout: uiTimeoutMs });
+    });
+}
+
+async function readPersistedSettings(pluginDir: string): Promise<PersistedSettings> {
+    return JSON.parse(await readFile(join(pluginDir, "data.json"), "utf8")) as PersistedSettings;
+}
+
+async function main(): Promise<void> {
+    const binary = requireObsidianBinary();
+    const cli = discoverObsidianCli();
+    if (!cli.binary) throw new Error(`Could not find obsidian-cli. Checked paths: ${cli.checked.join(", ")}`);
+    const vault = await createTemporaryVault("obsidian-livesync-remote-setup-e2e-");
+    let session: ObsidianLiveSyncSession | undefined;
+    try {
+        session = await startObsidianLiveSyncSession({
+            binary,
+            cliBinary: cli.binary,
+            localStorageEntries: createE2eObsidianDeviceLocalState(vault.name),
+            pluginData: createE2eCouchDbPluginData(
+                {
+                    dbName: "remote-setup-ui-only",
+                    password: "",
+                    uri: "http://127.0.0.1:5984",
+                    username: "",
+                },
+                {
+                    notifyThresholdOfRemoteStorageSize: 0,
+                    periodicReplication: false,
+                    syncAfterMerge: false,
+                    syncOnEditorSave: false,
+                    syncOnFileOpen: false,
+                    syncOnSave: false,
+                    syncOnStart: false,
+                    useAdvancedMode: true,
+                }
+            ),
+            startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
+            vault,
+        });
+        await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
+        const port = obsidianRemoteDebuggingPort();
+        await installRemoteSetupTestSeam(port);
+        await openRemoteConfigurationSettings(port, uiTimeoutMs);
+
+        await beginRemoteProfileSetup(port, "Cancelled CouchDB profile", uiTimeoutMs);
+        const selectionScreenshot = await captureRemoteProviderChoices(
+            port,
+            "remote-setup-provider-selection.png",
+            providerChoices,
+            uiTimeoutMs
+        );
+        await selectRemoteProvider(port, "CouchDB", "Continue to CouchDB setup", "CouchDB Configuration", uiTimeoutMs);
+        const couchdbScreenshot = await captureAndCancelRemoteProvider(
+            port,
+            "remote-setup-couchdb.png",
+            "CouchDB Configuration",
+            uiTimeoutMs
+        );
+        const p2pScreenshot = await mountLegacyProvider(
+            port,
+            "Cancelled P2P profile",
+            "Peer-to-Peer (P2P)",
+            "Continue to P2P setup",
+            "P2P Configuration",
+            "remote-setup-p2p.png"
+        );
+
+        const s3Screenshot = await addS3Profile(port);
+        const webdavScreenshot = await addWebDAVProfile(port);
+        const postgrestScreenshot = await addPostgRESTProfile(port);
+        const firstRuntimeSettings = (await runtimeRemoteSettings(port)) as PersistedSettings;
+        assertPersistedProfiles(firstRuntimeSettings);
+        const calls = await remoteSetupCalls(port);
+        assertEqual(
+            calls.filter((call) => call.operation === "test").length,
+            1,
+            "The S3 profile did not use the injected connection-test boundary exactly once."
+        );
+        if (calls.filter((call) => call.operation === "inspect").length < 5) {
+            throw new Error("The WebDAV and PostgREST profiles did not exercise failure, stale, and verified checks.");
+        }
+
+        const pluginDir = session.install.pluginDir;
+        assertEncryptedProfilesAtRest(await readPersistedSettings(pluginDir));
+        await closeRemoteConfigurationSettings(port, uiTimeoutMs);
+        await enableAndReloadPlugin(port, "obsidian-livesync");
+        await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
+        await openRemoteConfigurationSettings(port, uiTimeoutMs);
+        await assertReloadedS3(port);
+        await assertReloadedWebDAV(port);
+        await assertReloadedPostgREST(port);
+        const reloadedSettings = (await runtimeRemoteSettings(port)) as PersistedSettings;
+        assertPersistedProfiles(reloadedSettings);
+        assertEqual(
+            Object.keys(reloadedSettings.remoteConfigurations).length,
+            Object.keys(firstRuntimeSettings.remoteConfigurations).length,
+            "Plug-in reload changed the saved remote profile count."
+        );
+        const listScreenshot = await captureObsidianElement(port, "remote-setup-reloaded-profiles.png", (page: Page) =>
+            page.locator(".sls-setting .sls-remote-list")
+        );
+
+        console.log(
+            `All registered providers mounted through the real Settings flow; S3, WebDAV, and PostgREST passed validation, injected checks, persistence, and plug-in reload. Screenshots: ${[
+                selectionScreenshot,
+                couchdbScreenshot,
+                p2pScreenshot,
+                s3Screenshot,
+                webdavScreenshot,
+                postgrestScreenshot,
+                listScreenshot,
+            ].join(", ")}`
+        );
+    } finally {
+        if (session) await session.app.stop();
+        await vault.dispose();
+    }
+}
+
+main().catch((error: unknown) => {
+    console.error(error instanceof Error ? error.stack : error);
+    process.exit(1);
+});

test/e2e-obsidian/scripts/run-focused.ts

@@ -11,6 +11,7 @@ const focusedScenarios = new Set([
     "revision-repair",
     "document-history-nav",
     "settings-ui",
+    "remote-setup-providers",
     "review-harness",
     "p2p-pane",
     "vault-reflection",
@@ -18,6 +19,7 @@ const focusedScenarios = new Set([
     "couchdb-manual-setup-workflow",
     "cli-to-obsidian-sync",
     "minio-upload",
+    "adaptive-postgrest",
     "object-storage-setup-uri-workflow",
     "p2p-setup-uri-workflow",
     "startup-scan",
@@ -38,7 +40,7 @@ real-Obsidian scenario. Supported scenarios:
 
 ${[...focusedScenarios].map((scenario) => `  ${scenario}`).join("\n")}
 
-This wrapper does not start CouchDB, Object Storage, or the P2P signalling
+This wrapper does not start CouchDB, Object Storage, PostgREST, or the P2P signalling
 relay. Use the documented service commands or the complete
 local-suite:services wrapper when required.`;
 }

updates.md

@@ -18,6 +18,7 @@ Earlier releases remain available in the 0.25 release history and the legacy rel
 
 - Object Storage setup can select the experimental Adaptive Journal format and choose complete Pack or verified Range retrieval. Existing Opaque Journal repositories remain the default and require an explicit remote Rebuild before changing formats.
 - Saved connections and Setup now support experimental WebDAV Journal profiles. Adaptive WebDAV runs an endpoint safety check, reports required immutable-object behaviour separately from optional Range support, and permits an unverified save only from Settings.
+- Saved connections and Setup now support experimental, Adaptive-only PostgREST Journal profiles. Setup verifies the packaged RPC contract and binary semantics, the adapter rejects recognised privileged Supabase keys before a request, and Opaque Journal, Pack, and Range options remain outside this provider.
 
 ### P2P and experimental browser applications