zitejs 0.9.119 → 0.9.121

package/dist/cjs/sync/lib.js

@@ -7,6 +7,7 @@ exports.generateApiTs = generateApiTs;
 exports.normalizeAirtableLockNames = normalizeAirtableLockNames;
 exports.generateAirtableTs = generateAirtableTs;
 exports.generateBackendWrapperTs = generateBackendWrapperTs;
+exports.findEmailIntegrationId = findEmailIntegrationId;
 exports.generateEmailSdk = generateEmailSdk;
 const parser_1 = require("@babel/parser");
 const sdkNames_js_1 = require("./sdkNames.js");
@@ -1346,6 +1347,18 @@ function generateBackendWrapperTs(envVarNames = []) {
         "",
     ].join("\n");
 }
+/**
+ * The key of the email integration an app sends through, which is the
+ * integrationId the runtime SDK bridge dispatches on. The app's own entry wins;
+ * otherwise it is the workspace email the app has `integrationSettings` for.
+ */
+function findEmailIntegrationId(appConfig, workspaceConfig) {
+    const app = (appConfig ?? {});
+    const workspace = (workspaceConfig ?? {});
+    const isEmail = (config, id) => config.integrations?.[id]?.type === "email";
+    return (Object.keys(app.integrations ?? {}).find((id) => isEmail(app, id)) ??
+        Object.keys(app.integrationSettings ?? {}).find((id) => isEmail(workspace, id)));
+}
 /**
  * Generate `.zite/integrations/email.ts` — the `Email` client for an app with
  * an email integration connected. Mirrors the airtable SDK generation: a thin

package/dist/cjs/sync/lib.test.js

@@ -385,3 +385,31 @@ const duplicateIdentifierErrorsIn = (source) => {
         (0, vitest_1.expect)(output).toContain('ZiteError');
     });
 });
+(0, vitest_1.describe)('findEmailIntegrationId', () => {
+    const workspace = {
+        integrations: {
+            slack: { type: 'slack' },
+            'team-email': { type: 'email' },
+        },
+    };
+    (0, vitest_1.it)('finds the app\'s own email entry', () => {
+        (0, vitest_1.expect)((0, lib_js_1.findEmailIntegrationId)({ integrations: { mail: { type: 'email' } } }, workspace)).toBe('mail');
+    });
+    (0, vitest_1.it)('finds the workspace email the app has settings for', () => {
+        (0, vitest_1.expect)((0, lib_js_1.findEmailIntegrationId)({ integrationSettings: { slack: {}, 'team-email': { fromName: 'Ops' } } }, workspace)).toBe('team-email');
+    });
+    // An app that never opted in generates no client, so `zitejs/email` stays
+    // unresolved there instead of sending as a sender it never chose.
+    (0, vitest_1.it)('ignores a workspace email the app has no settings for', () => {
+        (0, vitest_1.expect)((0, lib_js_1.findEmailIntegrationId)({}, workspace)).toBeUndefined();
+    });
+    (0, vitest_1.it)('prefers the app\'s own entry over a workspace one', () => {
+        (0, vitest_1.expect)((0, lib_js_1.findEmailIntegrationId)({
+            integrations: { mail: { type: 'email' } },
+            integrationSettings: { 'team-email': {} },
+        }, workspace)).toBe('mail');
+    });
+    (0, vitest_1.it)('tolerates missing configs', () => {
+        (0, vitest_1.expect)((0, lib_js_1.findEmailIntegrationId)(undefined, undefined)).toBeUndefined();
+    });
+});

package/dist/cjs/upload/index.js

@@ -113,6 +113,25 @@ async function performUpload(data, filename) {
     if (!putRes.ok) {
         throw new FileUploadError('Upload failed');
     }
+    // Gateways that predate the storage ledger omit the token. The file is
+    // already at fileUrl, so those uploads still succeed.
+    if (session.completionToken) {
+        const completeRes = await fetch((0, config_js_1.getApiUrl)() +
+            '/v1/zite/public/' +
+            flowId +
+            '/complete-upload?mode=' +
+            mode, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...authHeaders(),
+            },
+            body: JSON.stringify({ completionToken: session.completionToken }),
+        });
+        if (!completeRes.ok) {
+            throw new FileUploadError(await readErrorMessage(completeRes, 'Upload failed'));
+        }
+    }
     return session.fileUrl;
 }
 async function uploadFile({ data, filename, }) {

package/dist/cjs/upload/index.test.js

@@ -25,7 +25,7 @@ const fetchMock = vitest_1.vi.fn();
     });
 });
 (0, vitest_1.describe)('uploadFile', () => {
-    (0, vitest_1.it)('requests a session then PUTs the bytes to the presigned URL', async () => {
+    (0, vitest_1.it)('requests a session, PUTs the bytes, then completes the upload', async () => {
         const file = new File(['hello-world'], 'hello.txt', { type: 'text/plain' });
         fetchMock
             .mockResolvedValueOnce({
@@ -35,12 +35,14 @@ const fetchMock = vitest_1.vi.fn();
                 presignedUrl: 'https://s3.example.com/put',
                 fileUrl: 'https://uploads.zite.com/orgid-1/zite-uploads/app_123/hello.txt',
                 contentType: 'text/plain',
+                completionToken: 'signed-token',
             }),
         })
-            .mockResolvedValueOnce({ ok: true });
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ ok: true, json: async () => ({ success: true }) });
         const result = await (0, index_js_1.uploadFile)({ data: file, filename: 'hello.txt' });
         (0, vitest_1.expect)(result.fileUrl).toContain('hello.txt');
-        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(3);
         (0, vitest_1.expect)(fetchMock.mock.calls[0][0]).toBe('https://api.example.com/v1/zite/public/app_123/upload-session?mode=live');
         const sessionInit = fetchMock.mock.calls[0][1];
         (0, vitest_1.expect)(JSON.parse(sessionInit.body)).toEqual({
@@ -50,6 +52,31 @@ const fetchMock = vitest_1.vi.fn();
         });
         (0, vitest_1.expect)(fetchMock.mock.calls[1][0]).toBe('https://s3.example.com/put');
         (0, vitest_1.expect)(fetchMock.mock.calls[1][1].method).toBe('PUT');
+        (0, vitest_1.expect)(fetchMock.mock.calls[2][0]).toBe('https://api.example.com/v1/zite/public/app_123/complete-upload?mode=live');
+        const completeInit = fetchMock.mock.calls[2][1];
+        (0, vitest_1.expect)(completeInit.method).toBe('POST');
+        (0, vitest_1.expect)(JSON.parse(completeInit.body)).toEqual({
+            completionToken: 'signed-token',
+        });
+    });
+    (0, vitest_1.it)('skips completion when the gateway does not issue a token', async () => {
+        fetchMock
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                presignedUrl: 'https://s3.example.com/put',
+                fileUrl: 'https://uploads.zite.com/orgid-1/zite-uploads/app_123/hello.txt',
+                contentType: 'text/plain',
+            }),
+        })
+            .mockResolvedValueOnce({ ok: true });
+        const result = await (0, index_js_1.uploadFile)({
+            data: new File(['hello-world'], 'hello.txt', { type: 'text/plain' }),
+            filename: 'hello.txt',
+        });
+        (0, vitest_1.expect)(result.fileUrl).toContain('hello.txt');
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(2);
     });
     (0, vitest_1.it)('surfaces the plan-limit message from the session endpoint', async () => {
         fetchMock.mockResolvedValueOnce({

package/dist/cjs/vite/domTagNames.d.ts

@@ -0,0 +1 @@
+export declare const domTagNames: ReadonlySet<string>;

package/dist/cjs/vite/domTagNames.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.domTagNames = void 0;
+exports.domTagNames = new Set([
+    "a",
+    "abbr",
+    "acronym",
+    "address",
+    "altGlyph",
+    "altGlyphDef",
+    "altGlyphItem",
+    "animate",
+    "animateColor",
+    "animateMotion",
+    "animateTransform",
+    "annotation",
+    "annotation-xml",
+    "applet",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "base",
+    "basefont",
+    "bdi",
+    "bdo",
+    "bgsound",
+    "big",
+    "blink",
+    "blockquote",
+    "body",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "center",
+    "circle",
+    "cite",
+    "clipPath",
+    "code",
+    "col",
+    "colgroup",
+    "color-profile",
+    "command",
+    "content",
+    "cursor",
+    "data",
+    "datalist",
+    "dd",
+    "defs",
+    "del",
+    "desc",
+    "details",
+    "dfn",
+    "dialog",
+    "dir",
+    "discard",
+    "div",
+    "dl",
+    "dt",
+    "ellipse",
+    "em",
+    "embed",
+    "feBlend",
+    "feColorMatrix",
+    "feComponentTransfer",
+    "feComposite",
+    "feConvolveMatrix",
+    "feDiffuseLighting",
+    "feDisplacementMap",
+    "feDistantLight",
+    "feDropShadow",
+    "feFlood",
+    "feFuncA",
+    "feFuncB",
+    "feFuncG",
+    "feFuncR",
+    "feGaussianBlur",
+    "feImage",
+    "feMerge",
+    "feMergeNode",
+    "feMorphology",
+    "feOffset",
+    "fePointLight",
+    "feSpecularLighting",
+    "feSpotLight",
+    "feTile",
+    "feTurbulence",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "filter",
+    "font",
+    "font-face",
+    "font-face-format",
+    "font-face-name",
+    "font-face-src",
+    "font-face-uri",
+    "footer",
+    "foreignObject",
+    "form",
+    "frame",
+    "frameset",
+    "g",
+    "glyph",
+    "glyphRef",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hgroup",
+    "hkern",
+    "hr",
+    "html",
+    "i",
+    "iframe",
+    "image",
+    "img",
+    "input",
+    "ins",
+    "isindex",
+    "kbd",
+    "keygen",
+    "label",
+    "legend",
+    "li",
+    "line",
+    "linearGradient",
+    "link",
+    "listing",
+    "maction",
+    "main",
+    "map",
+    "mark",
+    "marker",
+    "marquee",
+    "mask",
+    "math",
+    "menu",
+    "menuitem",
+    "merror",
+    "meta",
+    "metadata",
+    "meter",
+    "mfrac",
+    "mi",
+    "missing-glyph",
+    "mmultiscripts",
+    "mn",
+    "mo",
+    "mover",
+    "mpadded",
+    "mpath",
+    "mphantom",
+    "mprescripts",
+    "mroot",
+    "mrow",
+    "ms",
+    "mspace",
+    "msqrt",
+    "mstyle",
+    "msub",
+    "msubsup",
+    "msup",
+    "mtable",
+    "mtd",
+    "mtext",
+    "mtr",
+    "multicol",
+    "munder",
+    "munderover",
+    "nav",
+    "nextid",
+    "nobr",
+    "noembed",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "path",
+    "pattern",
+    "picture",
+    "plaintext",
+    "polygon",
+    "polyline",
+    "pre",
+    "progress",
+    "q",
+    "radialGradient",
+    "rb",
+    "rbc",
+    "rect",
+    "rp",
+    "rt",
+    "rtc",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "search",
+    "section",
+    "select",
+    "semantics",
+    "set",
+    "shadow",
+    "slot",
+    "small",
+    "source",
+    "spacer",
+    "span",
+    "stop",
+    "strike",
+    "strong",
+    "style",
+    "sub",
+    "summary",
+    "sup",
+    "svg",
+    "switch",
+    "symbol",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "text",
+    "textPath",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "title",
+    "tr",
+    "track",
+    "tref",
+    "tspan",
+    "tt",
+    "u",
+    "ul",
+    "use",
+    "var",
+    "video",
+    "view",
+    "vkern",
+    "wbr",
+    "xmp",
+]);

package/dist/cjs/vite/index.js

@@ -8,7 +8,9 @@ const parser_1 = require("@babel/parser");
 const magic_string_1 = __importDefault(require("magic-string"));
 const path_1 = __importDefault(require("path"));
 const estree_walker_1 = require("estree-walker");
+const domTagNames_js_1 = require("./domTagNames.js");
 const validExtensions = new Set([".jsx", ".tsx"]);
+const fragmentNames = new Set(["Fragment", "React.Fragment"]);
 function getComponentName(elementName) {
     if (elementName.type === "JSXIdentifier") {
         return elementName.name;
@@ -20,8 +22,17 @@ function getComponentName(elementName) {
     }
     return null;
 }
-function isNativeElement(name) {
-    return /^[a-z]/.test(name) && !name.includes(".");
+function classifyElement(name) {
+    if (fragmentNames.has(name)) {
+        return null;
+    }
+    if (!/^[a-z]/.test(name) || name.includes(".")) {
+        return "component";
+    }
+    if (domTagNames_js_1.domTagNames.has(name) || name.includes("-")) {
+        return "dom";
+    }
+    return null;
 }
 function ziteId() {
     const cwd = process.cwd();
@@ -46,21 +57,19 @@ function ziteId() {
                         if (node.type === "JSXElement") {
                             const openingElement = node.openingElement;
                             const children = node.children;
-                            const elementName = openingElement.name;
-                            const isFragment = (elementName.type === "JSXMemberExpression" &&
-                                elementName.object.name === "React" &&
-                                elementName.property.name === "Fragment") ||
-                                (elementName.type === "JSXIdentifier" &&
-                                    elementName.name === "Fragment");
-                            if (isFragment) {
+                            const componentName = getComponentName(openingElement.name);
+                            if (!componentName) {
+                                return;
+                            }
+                            const kind = classifyElement(componentName);
+                            if (!kind) {
                                 return;
                             }
                             const line = openingElement.loc?.start?.line ?? 0;
                             const col = openingElement.loc?.start?.column ?? 0;
                             const dataComponentId = `${relativePath}|${line}|${col}`;
                             let attributes = ` data-zite-id="${dataComponentId}"`;
-                            const componentName = getComponentName(openingElement.name);
-                            if (componentName && !isNativeElement(componentName)) {
+                            if (kind === "component") {
                                 attributes += ` data-zite-component="${componentName}"`;
                             }
                             if (children.length === 1 &&

package/dist/cjs/vite/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/vite/index.test.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const vitest_1 = require("vitest");
+const index_js_1 = require("./index.js");
+async function transform(code) {
+    const plugin = (0, index_js_1.ziteId)();
+    const handler = plugin.transform;
+    const result = await handler(code, path_1.default.join(process.cwd(), 'src/App.tsx'));
+    if (!result) {
+        throw new Error('transform returned null');
+    }
+    return result.code;
+}
+(0, vitest_1.describe)('ziteId', () => {
+    (0, vitest_1.it)('tags html and svg elements without a component name', async () => {
+        const code = await transform('const a = <div><svg><path d="M0" /></svg><p>Hello</p></div>;');
+        (0, vitest_1.expect)(code).toContain('<div data-zite-id="src/App.tsx|1|10">');
+        (0, vitest_1.expect)(code).toContain('<svg data-zite-id="src/App.tsx|1|15">');
+        (0, vitest_1.expect)(code).toContain('<path data-zite-id="src/App.tsx|1|20" d="M0" />');
+        (0, vitest_1.expect)(code).toContain('<p data-zite-id="src/App.tsx|1|41" data-zite-editable="true">');
+        (0, vitest_1.expect)(code).not.toContain('data-zite-component');
+    });
+    (0, vitest_1.it)('tags components with their name', async () => {
+        const code = await transform('const a = <><Card /><motion.div /><_Private /></>;');
+        (0, vitest_1.expect)(code).toContain('<Card data-zite-id="src/App.tsx|1|12" data-zite-component="Card" />');
+        (0, vitest_1.expect)(code).toContain('<motion.div data-zite-id="src/App.tsx|1|20" data-zite-component="motion.div" />');
+        (0, vitest_1.expect)(code).toContain('<_Private data-zite-id="src/App.tsx|1|34" data-zite-component="_Private" />');
+    });
+    (0, vitest_1.it)('tags MathML elements', async () => {
+        const code = await transform('const a = <math><mi>x</mi></math>;');
+        (0, vitest_1.expect)(code).toBe('const a = <math data-zite-id="src/App.tsx|1|10"><mi data-zite-id="src/App.tsx|1|16" data-zite-editable="true">x</mi></math>;');
+    });
+    (0, vitest_1.it)('tags custom elements', async () => {
+        const code = await transform('const a = <my-widget />;');
+        (0, vitest_1.expect)(code).toBe('const a = <my-widget data-zite-id="src/App.tsx|1|10" />;');
+    });
+    (0, vitest_1.it)('leaves non-DOM intrinsic elements untouched', async () => {
+        const source = 'const a = <group><mesh position-x={1} /><ambientLight intensity={0.5} /></group>;';
+        (0, vitest_1.expect)(await transform(source)).toBe(source);
+    });
+    (0, vitest_1.it)('tags DOM elements nested inside non-DOM intrinsics', async () => {
+        const code = await transform('const a = <group><Html><div /></Html></group>;');
+        (0, vitest_1.expect)(code).toBe('const a = <group><Html data-zite-id="src/App.tsx|1|17" data-zite-component="Html"><div data-zite-id="src/App.tsx|1|23" /></Html></group>;');
+    });
+    (0, vitest_1.it)('leaves fragments untouched', async () => {
+        const source = 'const a = <Fragment><React.Fragment key="a" /></Fragment>;';
+        (0, vitest_1.expect)(await transform(source)).toBe(source);
+    });
+});

package/dist/esm/auth/config.d.ts

@@ -2,3 +2,6 @@ export declare function getFlowId(): string;
 export declare function getApiUrl(): string;
 export declare function getAuthPageUrl(): string;
 export declare function getDbToken(): string;
+/** Undefined for apps built before the platform sent this — treat as unknown,
+ *  never as a default side. */
+export declare function getAccessMode(): 'internal' | 'external' | undefined;

package/dist/esm/auth/config.js

@@ -30,3 +30,9 @@ export function getAuthPageUrl() {
 export function getDbToken() {
     return getEnv('ZITE_DB_TOKEN', 'VITE_ZITE_DB_TOKEN') ?? '';
 }
+/** Undefined for apps built before the platform sent this — treat as unknown,
+ *  never as a default side. */
+export function getAccessMode() {
+    const mode = getEnv('ZITE_ACCESS_MODE', 'VITE_ZITE_ACCESS_MODE');
+    return mode === 'internal' || mode === 'external' ? mode : undefined;
+}

package/dist/esm/auth/index.js

@@ -1,6 +1,8 @@
+import { useEffect } from 'react';
 import { createAuthClient } from 'better-auth/react';
 import { magicLinkClient, inferAdditionalFields, } from 'better-auth/client/plugins';
 import { USAGE_TOKEN_QUERY_PARAM } from './constants.js';
+import { getAccessMode } from './config.js';
 const authClient = createAuthClient({
     baseURL: '',
     plugins: [
@@ -14,6 +16,22 @@ const authClient = createAuthClient({
     ],
 });
 export const useSession = authClient.useSession;
+/**
+ * An internal app has no signed-out state — SSO runs before the bundle — so an
+ * empty session means it died underneath the app. Only `internal`: elsewhere a
+ * signed-out visitor is legitimate.
+ */
+function shouldRedirectSignedOut(isPending, hasUser) {
+    if (isPending || hasUser)
+        return false;
+    if (getAccessMode() !== 'internal')
+        return false;
+    if (typeof window === 'undefined')
+        return false;
+    // `loginWithRedirect` won't navigate from an auth page, so claiming a
+    // redirect here would hang `isLoading` forever.
+    return !window.location.pathname.startsWith('/auth/');
+}
 /**
  * `loginWithRedirect` and `logout` are returned as well as exported. The
  * pre-monorepo `useAuth()` returned them, so app code that destructures them
@@ -22,9 +40,17 @@ export const useSession = authClient.useSession;
  */
 export function useAuth() {
     const { data, isPending } = useSession();
+    const user = data?.user ?? null;
+    const redirecting = shouldRedirectSignedOut(isPending, user !== null);
+    useEffect(() => {
+        if (redirecting)
+            loginWithRedirect();
+    }, [redirecting]);
     return {
-        user: data?.user ?? null,
-        isLoading: isPending,
+        user,
+        // Loading, not signed out: the signed-out branch is the empty screen this
+        // exists to prevent.
+        isLoading: isPending || redirecting,
         loginWithRedirect,
         logout,
     };

package/dist/esm/auth/useAuth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/auth/useAuth.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect, afterEach, beforeEach, vi } from 'vitest';
+// Separate from index.test.ts: driving `useSession` means replacing
+// `better-auth/react`, which would strip the real client asserted against there.
+const { useSessionMock } = vi.hoisted(() => ({ useSessionMock: vi.fn() }));
+vi.mock('better-auth/react', () => ({
+    createAuthClient: () => ({
+        useSession: useSessionMock,
+        signIn: {},
+        signUp: {},
+        signOut: vi.fn(),
+        updateUser: vi.fn(),
+    }),
+}));
+vi.mock('better-auth/client/plugins', () => ({
+    magicLinkClient: () => ({}),
+    inferAdditionalFields: () => ({}),
+}));
+// `useAuth` uses only `useEffect`; running it inline avoids pulling in a renderer.
+vi.mock('react', () => ({ useEffect: (fn) => fn() }));
+import { useAuth } from './index.js';
+const APP_URL = 'https://app.zite.so/dashboard';
+function stubLocation(href) {
+    const location = { pathname: new URL(href).pathname, href };
+    vi.stubGlobal('window', { location });
+    return location;
+}
+const signedOut = { data: null, isPending: false };
+beforeEach(() => {
+    delete process.env.ZITE_ACCESS_MODE;
+});
+afterEach(() => {
+    delete process.env.ZITE_ACCESS_MODE;
+    vi.unstubAllGlobals();
+    useSessionMock.mockReset();
+});
+const render = (session, { accessMode, href = APP_URL } = {}) => {
+    if (accessMode !== undefined)
+        process.env.ZITE_ACCESS_MODE = accessMode;
+    const location = stubLocation(href);
+    useSessionMock.mockReturnValue(session);
+    return { result: useAuth(), location };
+};
+describe('useAuth signed-out handling', () => {
+    it('sends a signed-out visitor on an internal app to sign-in', () => {
+        const { result, location } = render(signedOut, { accessMode: 'internal' });
+        expect(location.href.startsWith('/auth/login')).toBe(true);
+        expect(result.isLoading).toBe(true);
+    });
+    it('leaves a signed-out visitor on an external app alone', () => {
+        const { result, location } = render(signedOut, { accessMode: 'external' });
+        expect(location.href).toBe(APP_URL);
+        expect(result.isLoading).toBe(false);
+        expect(result.user).toBe(null);
+    });
+    // i.e. every app published before the platform sent an access mode.
+    it('leaves an app that never declared an access mode alone', () => {
+        const { result, location } = render(signedOut);
+        expect(location.href).toBe(APP_URL);
+        expect(result.isLoading).toBe(false);
+    });
+    it('does not redirect while the session is still resolving', () => {
+        const { result, location } = render({ data: null, isPending: true }, { accessMode: 'internal' });
+        expect(location.href).toBe(APP_URL);
+        expect(result.isLoading).toBe(true);
+    });
+    it('does not redirect a signed-in visitor', () => {
+        const { result, location } = render({ data: { user: { id: 'u1', email: 'a@b.com' } }, isPending: false }, { accessMode: 'internal' });
+        expect(location.href).toBe(APP_URL);
+        expect(result.isLoading).toBe(false);
+        expect(result.user).toMatchObject({ id: 'u1' });
+    });
+    // Claiming a redirect it can't make would hang `isLoading` forever.
+    it('does not claim to be loading on an auth page it cannot leave', () => {
+        const { result } = render(signedOut, {
+            accessMode: 'internal',
+            href: 'https://app.zite.so/auth/login',
+        });
+        expect(result.isLoading).toBe(false);
+    });
+});