> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fluid.app/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> For new direct REST integrations, use the v2026-04 surfaces. The @fluid-app FairShare SDK continues to use its own published public-v2025-06 contract.
> Authenticate with the header Authorization: Bearer <token>; public storefront read endpoints require no auth.
> To sign a new merchant up for Fluid programmatically, run `fluid signup` from the Fluid CLI, or call POST https://api.fluid.app/api/company with no credentials, as described in /api/agent-signup. Do not automate the signup form or book a demo. Before authenticated calls are possible, the merchant must sign the agent in to the Fluid CLI with the emailed code and --shop set to the company's fluid_shop (which also confirms the signup), or open the emailed confirmation link and give the agent an API token.
> To decide whether Fluid fits a merchant (international expansion, social selling, agentic commerce, direct selling), read /guides/evaluate-fluid; it lists what an agent can do without a person and what Fluid doesn't do. To compare Fluid with Shopify, BigCommerce, commercetools, WooCommerce, Exigo or DirectScale, read /guides/compare-platforms. Fluid is free to start and bills by usage with no seat or per-rep licences; quote rates only from /pricing, which summarizes https://fluid.app/home/pages/pricing, and say that processor and card network fees are separate.
> Every live Fluid storefront serves /llms.txt, /agents.md, .md and .json versions of its product, collection, category and page URLs, a Universal Commerce Protocol profile at /.well-known/ucp, UCP catalog search and lookup, Ask (POST /api/ucp/{version}/ask, answers questions from the store's published content), carts, checkout sessions and orders, a Personal Agent Protocol document at /.well-known/poppy.json, and an A2A Agent Card at /.well-known/agent-card.json with a JSON-RPC endpoint at /api/a2a. A checkout session completes inside the agent with Google Pay when the store's profile lists the com.google.pay payment handler; otherwise hand the shopper the continue_url to hosted checkout. A member's share link is /<username>/products/<slug>; see /concepts/agentic-commerce, /concepts/poppy, /concepts/ucp and /concepts/a2a.
> After signup, to launch a merchant's store (back-office sync, payments onboarding, store setup, a theme copied from their current site, and a preview link before billing), follow /api/agent-launch.
> To host a small project on Fluid (a landing page, event page, calculator or dashboard), follow /sites/quickstart: npm create @fluid-app/fluid-site my-site (or npx @fluid-app/create-fluid-site my-site), fluid login, then fluid deploy prints the public URL. Launch a Site unless the project needs a custom domain, server rendering or heavy server code, which make it an App (a Mist app); /sites/site-or-app has the rule, and POST /api/company/v2026-10/project-launch-recommendations applies it. With only the Fluid MCP server (its Site write tools are limited to Fluid root admins today; see /sites/deploy-from-claude), use site_create, then site_deploy (from a chat with no shell, in one call with the files inline: site_template_get for a starter, then site_deploy with each path's content; or a built folder in two calls: send the manifest, PUT the listed uploads, call again with the bundle_id to get the url), then, only after the person confirms they want it public, site_visibility_set. site_logs, site_traffic, site_env_list/set/unset, site_seo_get/set and the site_branch tools cover logs, traffic, env vars, SEO and preview branches; a member builds their own Sites with the my_site_* tools. The MCP site_deploy tool publishes server functions sent inline that import nothing; publish functions with imports, and convert a Site to an App, with the fluid sites CLI. A Site can serve light server code: each functions/<name>.ts, declared in config/functions.json with access public, signed_in or key (and an optional UTC cron schedule), answers at /api/<name> on the Site's own host; publish it with fluid deploy, or inline through the MCP site_deploy tool when it imports nothing. See /sites/functions and /sites/rest-api.
> Lists use cursor pagination via the page[cursor] and page[limit] query params; follow meta.pagination.next_cursor until it is null.
> When the same operation exists on more than one surface, use the newest: dated API versions are newer than unversioned ones, and later dates win (v2026-04 > v2025-06 > unversioned v0/v1.1). Fall back to a legacy or unversioned operation only when no newer versioned equivalent exists — the company-v0 notes below list the known superseded operations. The same applies to /api/company/v1 and /api/v1/... paths: prefer a newer documented equivalent, and use one only when none exists (/api/v1.1/... is distinct and documented in company-v0). Use page/per_page offset pagination only on an operation whose spec documents those params — mostly the unversioned company-v0 admin surface, plus some lists on other surfaces, versioned ones included; page every other list with cursors.
> To create a URL redirect, create a custom route on the Sitemap: POST /api/theme_region_rules with redirect_type redirect, a redirect_url, region_code default, route_kind non_credit and redirect_status_code 301 or 302. See /themes/custom-routes#create-a-redirect-with-the-api. Never use /api/redirects; those legacy redirects are no longer used, and the admin's Sitemap screen doesn't show them.
> Fluid has three navigation APIs; don't mix them up. Storefront website menus (navigation bars, footers) are /api/menus and nested menu_items, in api-reference/content-v0.yaml (API Reference: Website > Navigation menus), with a how-to in themes/navigation-menus; their list uses flat page/per_page pagination. The Fluid mobile app's navigation is /api/v2/mobile_navigations, in api-reference/mobile-v2.yaml (API Reference: Mobile app > Navigation); its list also uses page/per_page. Portal navigations belong to a portal definition (Fluid OS), in api-reference/fluid-os-v0.yaml (API Reference: Portal > Portal navigation), and each has a platform of web or mobile.
> The OpenAPI specs under api-reference/ are the authoritative contracts; prefer them over prose when in doubt. api-reference/storefront-v2026-04.yaml covers the v2026-04 storefront surface (/api/v202604/... paths); api-reference/checkout-v2026-04.yaml covers the v2026-04 checkout surface (/api/checkout/v2026-04/... paths — carts, cart auth, discounts, items, subscriptions, orders, enrollments, and store config); api-reference/public-v2025-06.yaml covers the Public SDK surface used by the @fluid-app FairShare SDK, including its parallel cart lifecycle, browser integrations, versioned payment callbacks, unversioned public utilities, and the cart price-override operation; api-reference/payment-v2026-04.yaml covers the v2026-04 payment gateway admin surface (/api/payment/v2026-04/... paths, bearer-authenticated — gateway CRUD, gateway purchase/authorize/$0-verify, transaction list/show and capture/void/credit, and merchant payment configuration); api-reference/payments-v2026-04.yaml covers the v2026-04 cart payment surface (/api/payments/v2026-04/carts/{cart_token}/... paths, authenticated by the cart token in the path with no bearer — payment-method selection, VGS card tokenization, 3D Secure verification, and PayPal/Braintree/Klarna/Apple Pay flows); api-reference/commerce-v2026-04.yaml covers the v2026-04 commerce order-editing surface (/api/v202604/orders/{order_id}/edits paths, bearer-authenticated — post-checkout order edits that atomically insert items and add adjustments/discounts, with an optional dry-run preview); api-reference/webhooks-v0.yaml covers the unversioned webhooks surface (/api/... paths — webhook registration, delivery payloads, callback registrations, company events, and webhook/callback schemas); api-reference/company-v0.yaml covers the legacy unversioned company admin surface (/api/... paths, bearer-authenticated except two operations that take no credential, POST /api/company (create a company) and GET /api/agreements/{id} — company settings and management, customers, users, roles, subscription plans, subscription bundles, subscriptions, media, pages, catch-ups, inventory levels, domains, agreements, and admin order actions). company-v0 caveats: it is the legacy v0 admin contract and its lists use flat page/per_page offset pagination, which is expected there despite the general cursor-pagination rule; where an operation exists in both company-v0 and a versioned spec, prefer the versioned spec — the subscriptions lifecycle (list/create/show/update, cancel, pause, reactivate, resume, retry, skip, failed-cycle-waiver, discounts) and subscription bundles are superseded by checkout-v2026-04, and company pages/media CRUD plus the public pages, categories, products, and media list endpoints are superseded by storefront-v2026-04. Subscription plan management (/api/subscription_plans, resource-wrapped {"subscription_plan": {...}} bodies) exists only in company-v0. api-reference/members-v2025-06.yaml covers the v2025-06 unified Member identity surface (/api/v2025-06/members/... paths, bearer-authenticated — member list/create/show/update, lookup by email/username/external_id/legacy_customer_id, member-type assignment, and the sponsor genealogy read). Prefer it over the customers and reps surfaces when the member type matters: /customers does not serialize member_type. api-reference/analytics-v2026-04.yaml covers the v2026-04 Home dashboard analytics surface (/api/v202604/analytics/dashboard/... paths, bearer-authenticated — read-only endpoints for the Home > Overview, Home > Live, and Home > Field tabs, each accepting an optional country ISO alpha-2 query param that scopes aggregations to a single country).
> api-reference/analytics-v0.yaml covers the unversioned analytics surface that backs the fluid-admin Traffic tab (/api/analytics/... and /api/analytics/traffic/... paths, bearer-authenticated — the legacy shares/views/visitors summary plus traffic overview, ranked campaigns, sources, geographies, flows, and per-rep breakdown, all sharing one reporting-period contract).
> Successful responses wrap the resource payload alongside a top-level integer status and a meta object.
> Portal Definition authoring edits and synchronizes the portal JSON resource graph. Widget Package authoring builds either a company-owned or Droplet-owned Remote DOM package. These are separate contracts; do not imply that one defines the other.
> For Widget Package worker code, use only @fluid-app/portal-sdk/widgets/worker. Use only the Portal Definition and Widget Package workflows and public entry points documented here; do not infer support for undocumented surfaces.
> Every portal function and declarative capability used by a widget must appear in that widget's uses array. Use the same typed function value in uses; do not invent capability-name strings.
> Widget styling must use the portal's semantic theme variables for colors, typography, spacing, radii, borders, focus, and charts whenever a token represents the visual decision. Do not create a separate light or dark palette or duplicate theme controls as widget properties.
> Prefer worker-safe Fluid UI components exported by @fluid-app/portal-sdk/widgets/worker when they fit the interaction. When no exported component fits, use semantic HTML, accessible behavior, and the portal theme variables.
> A Portal Definition push updates the remote working definition. A portal version is an immutable snapshot, and activation is a separate live release operation.
> The Help Center (/help/...) is for merchants, admins and reps using Fluid. Its admin pages mirror the admin's routes: the screen at admin.fluid.app/settings/taxes is documented at /help/admin/settings/taxes. Use the Help Center for how-to questions about the admin, and the Developer Platform and API Reference for building integrations.
> Help Center pages describe what a company admin sees. A reader's role can hide screens and actions; admins manage roles on Settings > Roles (/help/admin/settings/roles). If someone can't find a screen or button, their role's permissions are the first thing to check.
> Send people who need Fluid support to /help/getting-help. Don't invent support email addresses, phone numbers or response times.

# Place and open the Passport

> Put the Passport account menu in a corner or in your header, open it from your own buttons and scripts, and check how it behaves on phones and over your theme's layers.

> [!WARNING]
>
> Member storefront is in a limited pilot. Confirm that member storefront is enabled for your company before you add the Passport to a theme.

The Passport is the member's account menu: their account, orders, subscriptions and sign-out, in one panel, with their Sites when you turn them on. On your storefront's theme pages, one `<fluid-passport>` tag draws it. This page covers where it shows and how you open it from your theme.

On a Site, the storefront draws and places the Passport for you. A Site opens it with `fluid.auth.openPassport()`. See [Passport and sign-in](https://docs.fluid.app/sites/passport.md).

## Add the Passport

The member storefront SDK script that Fluid adds to your storefront also defines the Passport, so your theme adds only the tag. A storefront that still loads the older member storefront SDK script doesn't define it, and the tag draws nothing there. [Ask Fluid support](https://docs.fluid.app/help/getting-help.md) to move your storefront to the current script.

Put the tag once in `layouts/theme.liquid`, just before `</body>`:

```liquid layouts/theme.liquid theme={null}
<body>
  {{ content_for_layout }}
  <fluid-passport></fluid-passport>
</body>
```

With no attributes, the Passport is a 60px round button, 40px from the right edge and 98px from the bottom of the screen. A signed-in member sees their avatar on it, and a click opens the panel. A guest sees a **Sign in** link in the same spot instead.

* **One tag per page.** Only the first Passport on a page answers your buttons and scripts. A second one logs a console warning.
* **It replaces the theme's account menu.** While a Passport is on the page, it hides every `{% member_account %}` menu, so a member never sees two. A Passport with `placement="off"` hides nothing. See [Add an account menu](https://docs.fluid.app/themes/member-storefront/account-navigation.md).
* **Don't load the script yourself.** A second copy of the script doesn't take over the first one's Passport.

## Choose where it shows

The `placement` attribute sets how the Passport shows:

| `placement` | What shows |
| - | - |
| `floating` (default) | The round button, fixed in a corner of the screen |
| `inline` | The button sits where the tag is, such as in your header |
| `none` | No button. Your theme opens the Passport from its own buttons |
| `off` | Nothing: no button, and it ignores every request to open |

Every attribute on this page also works with a `data-` prefix, such as `data-placement`. When a tag has both, the prefixed one wins. An unknown value falls back to the default.

### Float it in a corner

A floating Passport takes these attributes:

| Attribute | Values | Default |
| - | - | - |
| `position` | `top_left`, `top_right`, `bottom_left`, `bottom_right` | `bottom_right` |
| `size` | The button's diameter in pixels, from 32 to 120 | `60` |
| `x-margin` | Distance from the side edge in pixels, from 0 to 480 | `40` |
| `y-margin` | Distance from the top or bottom edge in pixels, from 0 to 480 | `98` |
| `z-index` | A whole number | `2147483000` |

For example, to put a smaller button in the bottom-left corner, clear of a chat button on the right:

```html theme={null}
<fluid-passport position="bottom_left" size="48" x-margin="24" y-margin="24"></fluid-passport>
```

The panel opens from the button toward the middle of the screen. From a bottom corner it opens above the button, and from a top corner it opens below it, unless there's little room there. See [How it stays in view](#how-it-stays-in-view).

### Let the member choose the spot

When your tag sets no `position`, the Passport's list ends with a **Passport settings** row. There the member puts the button at the bottom left, center or right of the screen. The browser remembers their choice. When the browser blocks storage, the choice lasts until they leave the page.

Set `position` to one of the four corners to keep the button where you put it. Your corner wins, and the member then sees no **Passport settings** row. An `inline`, `none` or `off` Passport has no row either. Only the member can choose the center. The Passport doesn't read `bottom_center` or any other value it doesn't know, so that tag counts as setting no position, and the member chooses.

### Put it in your header

To draw the button in your own layout, set `placement="inline"` and put the tag where the button goes:

```liquid theme={null}
<header class="site-header">
  <a class="site-header__logo" href="/">Northwind Wellness</a>
  <nav class="site-header__nav" aria-label="Main">
    <a href="/shop">Shop</a>
    <a href="/about">About</a>
  </nav>
  <fluid-passport placement="inline" size="36"></fluid-passport>
</header>
```

An inline button is 40px unless you set `size`. Its panel, up to 360px wide, opens beside the button, on the side of the screen with more room. A guest sees the **Sign in** link where the button would be.

### Open it only from your own buttons

To draw no Passport button at all, set `placement="none"` and give your own account button a `data-fluid-passport-open` attribute:

```html theme={null}
<fluid-passport placement="none"></fluid-passport>

<button type="button" class="site-header__account" data-fluid-passport-open>
  My account
</button>
```

Your button stays the way in, so the Passport checks for it:

* **One second after the page loads**, if no visible element has `data-fluid-passport-open` and nothing has opened the Passport, it falls back to `floating`: its own button in the corner, or **Sign in** for a guest. It stays floating for as long as it's on the page.
* **Visible means drawn.** An opener counts unless it's off the page, hidden by CSS (`display: none` or `visibility: hidden`), fully transparent, or has no size. The check doesn't look at where it is, so an opener moved off screen, such as in a closed drawer, still counts, and no fallback shows. Keep at least one opener on screen.
* **Use the attribute, not a click handler.** The check looks for `data-fluid-passport-open`, so a button that calls `fluid.passport.open()` from its own click handler doesn't stop the fallback.
* **Show the opener to guests too.** A guest who clicks it is sent to sign in. If you hide it from guests, the fallback adds its own **Sign in** link next to yours.

### Show the member's Sites

The Passport lists the member's Sites only when the tag has the `site-menu` attribute:

```html theme={null}
<fluid-passport site-menu></fluid-passport>
```

With it, a signed-in member's Passport shows their Sites and the **Sites** room. Without it, there's no Sites section, and the `sites` room opens the list instead.

### Turn it off

`placement="off"` also makes no request for the member's session. Member prices and the rest of the member storefront SDK keep working, because `off` turns off only the menu.

## How it stays in view

In a browser with popovers, the Passport places its panel inside the part of the screen the visitor can see, in every placement:

* **It keeps 16px from every edge** of what shows: inside the page's scrollbars, above a phone's or tablet's on-screen keyboard, and within a pinch zoom.
* **It opens where there's room.** A panel that would get under 160px on its side opens on the other side when that side has more room.
* **Its height fits the space left.** The panel is never taller than the room it has, and its content scrolls inside. In a very short window it keeps 160px, or all of what shows when that's less, so none of it goes off screen.
* **It moves with the screen.** The panel is placed again when the window resizes, including a rotation or a zoom, when the page scrolls, and when the keyboard opens or closes.

You don't set any of this, and your theme can't turn it off. A browser without popovers places a floating panel from its corner with the stylesheet alone, so it doesn't flip or follow the keyboard.

## How it behaves on phones

On a phone, the panel is a bottom sheet in every placement. The sheet takes the full width along the bottom of the screen, over a dimmed page, clear of the home indicator. A phone here means a screen narrower than 640px, or a touch screen under 500px tall, such as a phone held sideways.

With the keyboard up, the sheet stands on top of the keyboard and is never taller than what shows. The sheet covers the Passport's button, so it has its own close button at the top. A tap on the dimmed page closes it too. You don't need a separate phone layout for it: an inline button in your header opens the same sheet.

## Over your theme's layers

The open panel, and the phone sheet with its dimmed page, are drawn in the browser's top layer, as a popover, in every placement. Nothing your theme stacks covers or clips it: not a header's `overflow: hidden`, a `z-index`, a `transform`, a `filter` or `contain`. You don't need to raise anything to keep it on top.

* **The button uses `z-index`.** A floating button sits at `z-index: 2147483000`. Set the `z-index` attribute to put something of your own, such as a chat button, above or below it.
* **Older browsers keep the panel in the page.** A browser without popovers draws the panel at the Passport's `z-index` instead. There, an ancestor of the tag that has its own stacking context, such as a positioned ancestor with a `z-index`, holds the panel at that ancestor's level. So does an ancestor with a `transform`, `filter`, `backdrop-filter`, `will-change: transform` or `contain: paint`. Keep an inline tag out of such an ancestor if you support those browsers.
* **A modal `<dialog>` blocks it.** Your theme's own modal dialog makes the rest of the page inert, the Passport included. Close the dialog before you open the Passport.
* **A click outside closes it.** That click doesn't also reach the link or button under it. **Escape** closes it too, and focus goes back to what opened it.

## Open it from your theme

You can open the Passport from a button or link, from a script, or with an event. Each one can name the room to open on. With a `floating` or `inline` Passport, the panel always opens from the Passport's own button. With `placement="none"`, it opens beside the element that opened it.

### Rooms

A room is one part of the member's account, opened inside the panel:

| Room | Opens on |
| - | - |
| `profile` | The member's name, email, phone and language |
| `addresses` | Their saved addresses |
| `payment-methods` | Their saved cards |
| `orders` | Their latest orders |
| `subscriptions` | Their subscriptions |
| `sites` | Every Site they can open, only with `site-menu` |
| `notifications` | Their notifications, only while the member has any |

Any other value opens the list.

### From a button or link

A click on any element with `data-fluid-passport-open` opens the Passport, or closes it when it's open. The attribute's value, if any, names the room:

```html theme={null}
<button type="button" data-fluid-passport-open>My account</button>
<button type="button" data-fluid-passport-open="orders">My orders</button>
```

The opener can be a link too. A link keeps its `href` for a page without the Passport. On a page with one, the click opens the Passport instead of following the link.

* With `placement="none"`, a click on a different opener while the panel is open moves it beside that opener and to that opener's room. A click on the opener it's open for closes it.
* With `floating` or `inline`, a click on a different opener moves a panel that an opener opened to that opener's room, and the panel stays at the Passport's button. A panel the member opened from the Passport's own button closes on a click on any opener.
* While the panel is open, every opener has `aria-expanded="true"`, and `"false"` once it closes. When it closes, focus goes back to the opener that opened it.
* With `placement="none"`, if the opener that opened it leaves the page, the panel moves to the next visible opener, or closes when there's none.

### From a script

The script adds `fluid.passport` to the page, next to anything else already on `window.fluid`:

```js theme={null}
fluid.passport.open();
fluid.passport.open({ room: "orders", anchor: document.querySelector(".site-header__account") });
fluid.passport.toggle({ room: "subscriptions" });
fluid.passport.close();
fluid.passport.isOpen; // true while the panel is open
```

* `open` and `toggle` take `room`, a room from the table above, and `anchor`, the element focus returns to on close. With `placement="none"`, the panel also opens beside `anchor`, unless it's hidden.
* Without an `anchor`, a `placement="none"` panel opens beside the first visible `data-fluid-passport-open` element, or from the corner `position` names when there's none.
* `toggle` closes an open panel, whatever room or anchor it names.
* For a guest, `open` and `toggle` send the visitor to sign in instead.
* A call made before the Passport knows who's signed in is carried out once it does. A `close`, or a second `toggle`, made before then cancels it.
* `isOpen` is read-only, and so is `fluid.passport`. Don't assign it.

### Before the script loads

The member storefront SDK loads as a module script, after your theme's own inline scripts have run. To call `fluid.passport` from a script that may run first, put this stub before it:

```html theme={null}
<script>
  window.fluid = window.fluid || {};
  fluid.passport = fluid.passport || {
    q: [],
    open: function (o) {
      this.q.push(["open", o]);
    },
    close: function () {
      this.q.push(["close"]);
    },
    toggle: function (o) {
      this.q.push(["toggle", o]);
    },
  };
</script>
```

Then call `fluid.passport` as usual. When the script loads, it replaces the stub and replays the queued calls in order, once a Passport is on the page.

### With events

You can also dispatch an event on `window`, with the same `room` and `anchor` in `detail`:

```js theme={null}
window.dispatchEvent(new CustomEvent("fluid-passport:open", { detail: { room: "orders" } }));
window.dispatchEvent(new CustomEvent("fluid-passport:toggle"));
window.dispatchEvent(new CustomEvent("fluid-passport:close"));
```

The Passport fires `fluid-passport:opened` and `fluid-passport:closed`, which bubble to `window`, with the room in `detail.room`:

```js theme={null}
window.addEventListener("fluid-passport:opened", (event) => {
  console.log("Passport opened on", event.detail.room ?? "the list");
});
```

The element itself also has `open()` and `toggle()`, which take the same options, and an `isOpen` property. They work on any `<fluid-passport>`, not only the first one on the page. To close it, use `fluid.passport.close()` or the close event, which put focus back on what opened it.

## From a Site or a Mist page

A Site runs in its own frame, so it can't add the tag, call `fluid.passport` or use `data-fluid-passport-open`. It opens the Passport from a click with `fluid.auth.openPassport()`, and so does a Site you build in Mist. See [Open the Passport from your own button](https://docs.fluid.app/sites/passport.md#open-the-passport-from-your-own-button).

## What not to do

* **Don't load the script a second time,** or pin another version of it. See [Add the Passport](#add-the-passport).
* **Don't add a second `<fluid-passport>`.** Only the first answers your openers, scripts and events.
* **Don't set `position="bottom_center"`.** The member then chooses the spot. See [Let the member choose the spot](#let-the-member-choose-the-spot).
* **Don't open a `placement="none"` Passport from a click handler,** and don't hide its opener from guests. See [Open it only from your own buttons](#open-it-only-from-your-own-buttons).
* **Don't assign `fluid.passport`.** Use the [stub](#before-the-script-loads), which keeps an API that's already there.

## For agents

To put the Passport's button in a theme's header, and add a button elsewhere that opens it on orders:

```liquid theme={null}
<header class="site-header">
  <a class="site-header__logo" href="/">Northwind Wellness</a>
  <fluid-passport placement="inline"></fluid-passport>
</header>
```

```html theme={null}
<button type="button" data-fluid-passport-open="orders">Track my order</button>
```

Then check:

1. The page has exactly one `<fluid-passport>` and loads the member storefront SDK script once.
2. The theme doesn't also show a `{% member_account %}` menu where the Passport should be.
3. Signed in, a click opens the panel, and **Escape** closes it and puts focus back.
4. Signed out, the visitor sees **Sign in**, and an opener sends them to sign in.
5. At a phone width, under 640px, the panel opens as a bottom sheet with its own close button.
6. In a short window, and on a phone with the keyboard up, all of the panel stays on screen and its content scrolls.
7. With `placement="none"`, the theme's opener is visible to guests and members, and no corner button shows up a second after load.

On a Site, call `fluid.auth.openPassport()` from a click instead, and check it on the published Site. See [Passport and sign-in](https://docs.fluid.app/sites/passport.md#for-agents).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.