@softr/sdk 0.0.88-signing.0 → 0.0.89-alpha.0

package/dist/agent/use-agent-chat.js

@@ -0,0 +1,419 @@
+import { assert } from "../assertions.js";
+import { useCurrentUser } from "../auth/isomorphic.js";
+import { agentChatFn, decideAgentToolFn, listAgentChatsFn, loadAgentChatFn } from "./agent-fns.js";
+import { useCallback, useEffect, useRef, useState } from "react";
+
+//#region src/agent/use-agent-chat.ts
+/**
+* A chat with one of the app's Softr agents, as the signed-in visitor. No UI:
+* render `messages` with the app's own components.
+*
+* @example
+* const chat = useAgentChat(AGENT_ID, { record: ticket && { id: ticket.id, fields: ticket.fields } })
+* <form onSubmit={(e) => { e.preventDefault(); chat.send(draft) }}>
+*/
+function useAgentChat(agentId, options = {}) {
+	const [messages, setMessages] = useState([]);
+	const [live, setLive] = useState(null);
+	const [status, setStatus] = useState("idle");
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	const [chatId, setChatId] = useState(null);
+	const storeKey = chatKey(agentId, useCurrentUser()?.id ?? null);
+	const chatIdRef = useRef(chatId);
+	chatIdRef.current = chatId;
+	const recordRef = useRef(options.record ?? null);
+	recordRef.current = options.record ?? null;
+	const liveRef = useRef(live);
+	liveRef.current = live;
+	const abortRef = useRef(null);
+	useEffect(() => () => abortRef.current?.abort(), []);
+	const commitLive = useCallback((blocks) => {
+		setLive(null);
+		if (!blocks?.some((b) => b.type !== "text" || b.text.trim())) return;
+		setMessages((prev) => [...prev, {
+			id: crypto.randomUUID(),
+			role: "assistant",
+			blocks: endRunningTools(blocks)
+		}]);
+	}, []);
+	const stream = useCallback(async (message) => {
+		abortRef.current?.abort();
+		const controller = new AbortController();
+		abortRef.current = controller;
+		setError(null);
+		setStatus("thinking");
+		let blocks = [];
+		try {
+			const request = {
+				agentId,
+				message,
+				sessionId: chatIdRef.current,
+				timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+				pageName: document.title,
+				pageUrl: location.href,
+				record: recordRef.current
+			};
+			const form = new FormData();
+			form.append("payload", JSON.stringify(request));
+			const res = await fetch(agentChatFn.url, {
+				method: "POST",
+				body: form,
+				signal: controller.signal
+			});
+			if (!res.ok) throw new Error(await failureMessage(res));
+			assert(res.body, "agent chat: the reply has no body");
+			const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+			let buffer = "";
+			const onLine = (line) => {
+				const event = parseEvent(line);
+				if (event === null) return;
+				if (event.sessionId && event.sessionId !== chatIdRef.current) {
+					chatIdRef.current = event.sessionId;
+					setChatId(event.sessionId);
+					saveChatId(storeKey, event.sessionId);
+				}
+				blocks = reduceEvent(blocks, event);
+				setLive(blocks);
+				setStatus("replying");
+			};
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += value;
+				const lines = buffer.split("\n");
+				buffer = lines.pop() ?? "";
+				lines.forEach(onLine);
+			}
+			onLine(buffer);
+		} catch (err) {
+			if (controller.signal.aborted) return;
+			setError(err instanceof Error ? err : new Error(String(err)));
+		}
+		if (abortRef.current !== controller) return;
+		abortRef.current = null;
+		commitLive(blocks);
+		setStatus("idle");
+	}, [
+		agentId,
+		storeKey,
+		commitLive
+	]);
+	const send = useCallback((text) => {
+		const trimmed = text.trim();
+		if (!trimmed) return;
+		abortRef.current?.abort();
+		commitLive(liveRef.current);
+		setMessages((prev) => [...prev, {
+			id: crypto.randomUUID(),
+			role: "user",
+			blocks: [{
+				type: "text",
+				text: trimmed
+			}]
+		}]);
+		stream(trimmed);
+	}, [stream, commitLive]);
+	const stop = useCallback(() => {
+		if (abortRef.current === null) return;
+		abortRef.current.abort();
+		abortRef.current = null;
+		commitLive(liveRef.current);
+		setStatus("idle");
+	}, [commitLive]);
+	const reset = useCallback((id) => {
+		abortRef.current?.abort();
+		abortRef.current = null;
+		chatIdRef.current = id;
+		setChatId(id);
+		saveChatId(storeKey, id);
+		setMessages([]);
+		setLive(null);
+		setStatus("idle");
+		setLoading(false);
+		setError(null);
+	}, [storeKey]);
+	const newChat = useCallback(() => reset(null), [reset]);
+	const load = useCallback((id, restoring) => {
+		reset(id);
+		setLoading(true);
+		loadAgentChatFn({ data: {
+			agentId,
+			sessionId: id
+		} }).then((history) => {
+			if (chatIdRef.current !== id) return;
+			if (history === null) {
+				reset(null);
+				if (!restoring) setError(new Error(CHAT_GONE_MESSAGE));
+				return;
+			}
+			setLoading(false);
+			setMessages(fromHistory(history));
+		}).catch((err) => {
+			if (chatIdRef.current !== id) return;
+			setLoading(false);
+			setError(err instanceof Error ? err : new Error(String(err)));
+		});
+	}, [agentId, reset]);
+	const openChat = useCallback((id) => load(id, false), [load]);
+	useEffect(() => {
+		const saved = savedChatId(storeKey);
+		if (saved) load(saved, true);
+		else newChat();
+	}, [
+		storeKey,
+		load,
+		newChat
+	]);
+	const listChats = useCallback(() => listAgentChatsFn({ data: { agentId } }), [agentId]);
+	const setToolStatus = useCallback((toolCallId, next) => {
+		const update = (blocks) => blocks.map((b) => b.type === "tool" && b.id === toolCallId ? {
+			...b,
+			status: next
+		} : b);
+		setLive((prev) => prev && update(prev));
+		setMessages((prev) => prev.map((m) => ({
+			...m,
+			blocks: update(m.blocks)
+		})));
+	}, []);
+	const decide = useCallback((toolCallId, decision, scope) => {
+		const sessionId = chatIdRef.current;
+		const tool = [...messages.flatMap((m) => m.blocks), ...liveRef.current ?? []].find((b) => b.type === "tool" && b.id === toolCallId);
+		if (sessionId === null || tool?.status !== "awaiting-approval") return;
+		setToolStatus(toolCallId, decision === "APPROVE" ? "approved" : "rejected");
+		decideAgentToolFn({ data: {
+			agentId,
+			sessionId,
+			toolCallId,
+			toolName: tool.name,
+			decision,
+			scope
+		} }).then((saved) => {
+			if (!saved) {
+				reset(null);
+				setError(new Error(CHAT_GONE_MESSAGE));
+				return;
+			}
+			if (decision !== "APPROVE") return;
+			abortRef.current?.abort();
+			commitLive(liveRef.current);
+			stream("");
+		}).catch((err) => {
+			setToolStatus(toolCallId, "awaiting-approval");
+			setError(err instanceof Error ? err : new Error(String(err)));
+		});
+	}, [
+		agentId,
+		messages,
+		setToolStatus,
+		commitLive,
+		stream,
+		reset
+	]);
+	const approve = useCallback((toolCallId, scope = "ONCE") => decide(toolCallId, "APPROVE", scope), [decide]);
+	const reject = useCallback((toolCallId) => decide(toolCallId, "REJECT", "ONCE"), [decide]);
+	return {
+		messages: live === null ? messages : [...messages, {
+			id: "live",
+			role: "assistant",
+			blocks: live
+		}],
+		status,
+		loading,
+		error,
+		chatId,
+		send,
+		stop,
+		newChat,
+		openChat,
+		listChats,
+		approve,
+		reject
+	};
+}
+const TODO_TOOL = "TodoWrite";
+/** Its question shows as a question block, so the call itself is noise. */
+const QUESTION_TOOL = "AskUserQuestion";
+function parseEvent(line) {
+	if (!line.trim()) return null;
+	try {
+		return JSON.parse(line);
+	} catch {
+		return null;
+	}
+}
+function reduceEvent(blocks, event) {
+	switch (event.type) {
+		case "TEXT": {
+			const last = blocks.at(-1);
+			return last?.type === "text" ? [...blocks.slice(0, -1), {
+				type: "text",
+				text: last.text + event.response
+			}] : [...blocks, {
+				type: "text",
+				text: event.response
+			}];
+		}
+		case "TOOL_CALL_START":
+			if (event.toolName === TODO_TOOL) {
+				const todos = parseTodos(event.input);
+				if (todos) return upsertTodos(blocks, todos);
+			}
+			if (event.toolName === QUESTION_TOOL) return blocks;
+			if (blocks.some((b) => b.type === "tool" && b.id === event.toolCallId)) return updateTool(blocks, event.toolCallId, (b) => b.status === "running" ? {
+				...b,
+				input: event.input ?? b.input,
+				thought: event.innerThought ?? b.thought
+			} : b);
+			return [...blocks, {
+				type: "tool",
+				id: event.toolCallId,
+				name: event.toolName,
+				input: event.input,
+				thought: event.innerThought,
+				integration: event.integrationType,
+				status: "running"
+			}];
+		case "TOOL_CALL_END": return updateTool(blocks, event.toolCallId, (b) => b.status === "running" || b.status === "approved" ? {
+			...b,
+			status: event.failed ? "failed" : "done",
+			error: event.errorMessage,
+			durationMs: event.durationMs
+		} : b);
+		case "TOOL_PERMISSION_REQUEST":
+		case "INTEGRATION_AUTH_REQUEST": {
+			const status = event.type === "TOOL_PERMISSION_REQUEST" ? "awaiting-approval" : "awaiting-connection";
+			const integration = event.type === "INTEGRATION_AUTH_REQUEST" ? event.integrationType : void 0;
+			if (blocks.some((b) => b.type === "tool" && b.id === event.toolCallId)) return updateTool(blocks, event.toolCallId, (b) => ({
+				...b,
+				status,
+				integration: integration ?? b.integration,
+				input: ("input" in event ? event.input : void 0) ?? b.input
+			}));
+			return [...blocks, {
+				type: "tool",
+				id: event.toolCallId,
+				name: event.toolName,
+				input: "input" in event ? event.input : void 0,
+				integration,
+				status
+			}];
+		}
+		case "QUESTION": return [...blocks, {
+			type: "question",
+			questions: event.questions
+		}];
+		case "ERROR": return [...blocks, {
+			type: "error",
+			message: event.message
+		}];
+		default: return blocks;
+	}
+}
+function updateTool(blocks, id, update) {
+	return blocks.map((b) => b.type === "tool" && b.id === id ? update(b) : b);
+}
+/** A reply that ended without finishing a tool call, stopped or cut off, never will. */
+function endRunningTools(blocks) {
+	return blocks.map((b) => b.type === "tool" && b.status === "running" ? {
+		...b,
+		status: "failed",
+		error: "The agent stopped before this step finished."
+	} : b);
+}
+/** Each plan update re-sends the whole list, so only the latest one is kept, where the first one was. */
+function upsertTodos(blocks, todos) {
+	const index = blocks.findIndex((b) => b.type === "todo");
+	if (index === -1) return [...blocks, {
+		type: "todo",
+		todos
+	}];
+	return blocks.map((b, i) => i === index ? {
+		type: "todo",
+		todos
+	} : b);
+}
+function parseTodos(input) {
+	if (!input) return null;
+	try {
+		const parsed = JSON.parse(input);
+		if (typeof parsed !== "object" || parsed === null || !("todos" in parsed)) return null;
+		const outer = parsed.todos;
+		const raw = typeof outer === "object" && outer !== null && "todos" in outer ? outer.todos : outer;
+		if (!Array.isArray(raw)) return null;
+		const todos = raw.flatMap((item) => {
+			if (typeof item !== "object" || item === null) return [];
+			const { content, status } = item;
+			if (typeof content !== "string" || !content.trim()) return [];
+			if (status !== "pending" && status !== "in_progress" && status !== "completed") return [];
+			return [{
+				content,
+				status
+			}];
+		});
+		return todos.length > 0 ? todos : null;
+	} catch {
+		return null;
+	}
+}
+function fromHistory(history) {
+	const toolsByMessage = Map.groupBy(history.toolCalls, (call) => call.messageId);
+	return history.messages.filter((m) => m.role !== "USER" || m.content.trim()).map((m) => {
+		if (m.role === "USER") return {
+			id: m.id,
+			role: "user",
+			blocks: [{
+				type: "text",
+				text: m.content
+			}]
+		};
+		let blocks = [];
+		const calls = (toolsByMessage.get(m.id) ?? []).toSorted((a, b) => a.createdAt - b.createdAt);
+		for (const call of calls) {
+			const todos = call.toolName === TODO_TOOL ? parseTodos(call.input) : null;
+			if (todos) blocks = upsertTodos(blocks, todos);
+			else if (call.toolName !== QUESTION_TOOL) blocks.push({
+				type: "tool",
+				id: call.id,
+				name: call.toolName,
+				input: call.input,
+				thought: call.metadata.innerThought ?? void 0,
+				durationMs: call.metadata.durationMs ?? void 0,
+				status: call.metadata.failed ? "failed" : "done"
+			});
+		}
+		if (m.content) blocks.push({
+			type: "text",
+			text: m.content
+		});
+		return {
+			id: m.id,
+			role: "assistant",
+			blocks
+		};
+	});
+}
+const CHAT_GONE_MESSAGE = "This chat is no longer available. Start a new one.";
+const chatKey = (agentId, userId) => `softr-agent-chat:${agentId}:${userId ?? "visitor"}`;
+function savedChatId(key) {
+	try {
+		return localStorage.getItem(key);
+	} catch {
+		return null;
+	}
+}
+function saveChatId(key, chatId) {
+	try {
+		if (chatId) localStorage.setItem(key, chatId);
+		else localStorage.removeItem(key);
+	} catch {}
+}
+async function failureMessage(res) {
+	const body = await res.json().catch(() => null);
+	if (typeof body === "object" && body !== null && "message" in body && typeof body.message === "string") return body.message;
+	return `The agent could not answer (${res.status}).`;
+}
+
+//#endregion
+export { useAgentChat };

package/dist/auth/isomorphic.d.ts

@@ -14,14 +14,15 @@ import * as _tanstack_react_start0 from "@tanstack/react-start";
  * to read.
  *
  * Register it once, as a global request middleware in the app's `src/start.ts`.
- * It writes nothing but the session cookie.
+ * It writes the session cookie, and in production a header that stops other
+ * sites from embedding the app.
  *
  * @example
  * export const startInstance = createStart(() => ({
  *   requestMiddleware: [softrAuthMiddleware()],
  * }))
  */
-declare function softrAuthMiddleware(): _tanstack_react_start0.RequestMiddlewareAfterServer<{}, readonly [_tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>], {
+declare function softrAuthMiddleware(): _tanstack_react_start0.RequestMiddlewareAfterServer<{}, readonly [_tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>], {
   user: User | null;
   permissions: Permissions;
   formatting: Formatting;

package/dist/auth/isomorphic.js

@@ -9,6 +9,7 @@ import { settings } from "./methods/settings.js";
 import { bootErrorMiddleware } from "../boot-error.js";
 import { pwaMiddleware } from "../pwa.js";
 import { faviconMiddleware } from "../favicon.js";
+import { embeddingMiddleware } from "../embedding.js";
 import { createContext, useContext } from "react";
 import { createMiddleware, createServerFn, getGlobalStartContext } from "@tanstack/react-start";
 import { getRequestHeader } from "@tanstack/react-start/server";
@@ -22,7 +23,8 @@ import { jsx } from "react/jsx-runtime";
 * to read.
 *
 * Register it once, as a global request middleware in the app's `src/start.ts`.
-* It writes nothing but the session cookie.
+* It writes the session cookie, and in production a header that stops other
+* sites from embedding the app.
 *
 * @example
 * export const startInstance = createStart(() => ({
@@ -31,6 +33,7 @@ import { jsx } from "react/jsx-runtime";
 */
 function softrAuthMiddleware() {
 	return createMiddleware({ type: "request" }).middleware([
+		embeddingMiddleware(),
 		bootErrorMiddleware(),
 		pwaMiddleware(),
 		faviconMiddleware()

package/dist/auth/methods/authenticator.js

@@ -46,7 +46,7 @@ async function confirmAuthenticatorSetup(details) {
 		throw new Error(`${result.message}. Check SOFTR_APPLICATION_ID and that the app allows an authenticator app.`);
 	}
 	const { session, backupCodes } = result.data;
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);
@@ -75,7 +75,7 @@ async function skipAuthenticatorSetup() {
 	}
 	const { session } = result.data;
 	assert(session, "Expected a session from skipping setup, but got none");
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);
@@ -101,7 +101,7 @@ async function verifyAuthenticator(credentials) {
 	}
 	const { session } = result.data;
 	assert(session, "Expected a session from verification, but got none");
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);

package/dist/auth/methods/code.js

@@ -56,7 +56,7 @@ async function signInWithCode(credentials) {
 	}
 	const { session } = result.data;
 	assert(session, "Expected a session from sign-in, but got none");
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);

package/dist/auth/methods/magicLink.js

@@ -36,7 +36,7 @@ async function signInWithMagicLink(credentials) {
 	}
 	const { session } = result.data;
 	assert(session, "Expected a session from magic-link sign-in, but got none");
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);

package/dist/auth/methods/password.js

@@ -35,7 +35,7 @@ async function signIn(credentials) {
 	}
 	const { session } = result.data;
 	assert(session, "Expected a session from sign-in, but got none");
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);

package/dist/auth/methods/passwordLink.js

@@ -68,7 +68,7 @@ async function setPasswordWithLink(details) {
 	}
 	const { session } = result.data;
 	assert(session, "Expected a session from setting a password, but got none");
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);

package/dist/auth/methods/signup.js

@@ -66,7 +66,7 @@ async function confirmSignUp(details) {
 	}
 	const { session } = result.data;
 	assert(session, "Expected a session from sign-up, but got none");
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);

package/dist/auth/methods/social.js

@@ -41,7 +41,7 @@ async function signInWithGoogle(credentials) {
 	}
 	const { session } = result.data;
 	assert(session, "Expected a session from Google sign-in, but got none");
-	writeCookies([makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
+	writeCookies([...makeSessionTokenCookie(session.jwt), makeSessionDataCookie({
 		user: session.user,
 		permissions: session.permissions
 	}, session.jwt)]);

package/dist/auth/platform.js

@@ -1,8 +1,8 @@
 import { assert, panic } from "../assertions.js";
-import { softrApiUrl } from "../softr-api.js";
 import { fetch } from "../fetch.js";
-import { permissionsSchema } from "./permissions.js";
 import { softrConfig } from "../softr-config.js";
+import { permissionsSchema } from "./permissions.js";
+import { softrApiUrl } from "../softr-api.js";
 import { z } from "zod";
 
 //#region src/auth/platform.ts

package/dist/auth/session.js

@@ -1,4 +1,4 @@
-import { readRequestCookies, serializeCookie, writeCookies } from "../cookies.js";
+import { expireCookie, expireOtherCopy, readRequestCookies, serializeCookie, writeCookies } from "../cookies.js";
 import { permissionsSchema } from "./permissions.js";
 import { sessionConfig } from "./config.js";
 import { userSchema } from "./user.js";
@@ -65,12 +65,16 @@ function readSessionData(sessionToken) {
 		permissions: payload.permissions
 	};
 }
+/**
+* The token cookie, after a deletion of any copy from before `allowEmbedding`
+* changed. Both would be sent, and the old one could be read instead.
+*/
 function makeSessionTokenCookie(token) {
 	const { name, secure } = sessionCookie(SESSION_TOKEN);
-	return serializeCookie(name, sealEnvelope(token, SESSION_TOKEN), {
+	return [...expireOtherCopy(name, secure), serializeCookie(name, sealEnvelope(token, SESSION_TOKEN), {
 		maxAge: sessionConfig().sessionMaxAge,
 		secure
-	});
+	})];
 }
 function makeSessionDataCookie(session, sessionToken) {
 	const { name, secure } = sessionCookie(SESSION_DATA);
@@ -141,10 +145,7 @@ const sessionDataSchema = z.object({
 */
 function clearCookies(bases) {
 	const secure = requestIsSecure();
-	writeCookies(bases.flatMap((base) => secure ? [sessionCookieName(base, secure), base] : [base]).map((name) => serializeCookie(name, "", {
-		maxAge: 0,
-		secure
-	})));
+	writeCookies(bases.flatMap((base) => secure ? [sessionCookieName(base, secure), base] : [base]).flatMap((name) => expireCookie(name, secure)));
 }
 /**
 * Over the plaintext token, never the cookie value: that is resealed with a

package/dist/codegen/datasource-docs.js

@@ -73,15 +73,16 @@ function renderUserPropertiesDoc(users, context) {
 		"",
 		"```tsx",
 		"import { createFileRoute, redirect } from '@tanstack/react-router'",
-		"import { assertRouteAccess, defineVisibility } from '@softr/sdk'",
+		"import { assertRouteAccess, definePage, pageHead } from '@softr/sdk'",
 		"",
-		"const visibility = defineVisibility({ userGroupTypes: ['LOGGED_IN_USERS'] })",
+		"const pageSettings = definePage({ visibility: { userGroupTypes: ['LOGGED_IN_USERS'] }, title: 'Example' })",
 		"",
 		"export const Route = createFileRoute('/example')({",
 		"  beforeLoad: (opts) => {",
-		"    assertRouteAccess(visibility, opts)",
+		"    assertRouteAccess(pageSettings, opts)",
 		`    if (opts.context.user.properties.${first} == null) throw redirect({ to: '/' })`,
 		"  },",
+		"  head: pageHead(pageSettings),",
 		"})",
 		"```",
 		"",
@@ -90,14 +91,19 @@ function renderUserPropertiesDoc(users, context) {
 		"```tsx",
 		"import { createFileRoute } from '@tanstack/react-router'",
 		"import { createServerFn } from '@tanstack/react-start'",
+		"import { definePage, guardRoute, pageHead } from '@softr/sdk'",
 		"",
 		`const get${pascalCase(first)} = createServerFn().handler(async ({ context }) => {`,
 		"  if (!context.user) throw new Error('Not signed in')",
 		`  return context.user.properties.${first}`,
 		"})",
 		"",
+		"const pageSettings = definePage({ visibility: { userGroupTypes: ['LOGGED_IN_USERS'] }, title: 'Example' })",
+		"",
 		"export const Route = createFileRoute('/example')({",
+		"  beforeLoad: guardRoute(pageSettings),",
 		`  loader: () => get${pascalCase(first)}(),`,
+		"  head: pageHead(pageSettings),",
 		"  component: Example,",
 		"})",
 		"",

package/dist/cookies.js

@@ -1,4 +1,5 @@
 import { softAssert } from "./assertions.js";
+import { softrConfig } from "./softr-config.js";
 import { getRequestHeader, getResponseHeaders, setResponseHeader } from "@tanstack/react-start/server";
 
 //#region src/cookies.ts
@@ -36,8 +37,33 @@ function serializeCookie(name, value, { maxAge, secure }) {
 	return parts.join("; ");
 }
 function sameSiteAttributes(secure) {
-	if (secure && process.env.NODE_ENV !== "production") return ["SameSite=None", "Partitioned"];
-	return ["SameSite=Lax"];
+	return partitions(secure) ? ["SameSite=None", "Partitioned"] : ["SameSite=Lax"];
+}
+function partitions(secure) {
+	return secure && (process.env.NODE_ENV !== "production" || (softrConfig().allowEmbedding ?? []).length > 0);
+}
+function expired(name, partitioned) {
+	return partitioned ? `${name}=; Path=/; HttpOnly; Secure; SameSite=None; Partitioned; Max-Age=0` : `${name}=; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=0`;
+}
+/**
+* The deletions for one cookie. A browser keeps a partitioned and a plain
+* cookie of one name apart, and sends both. Which one the app wrote can change
+* between sign-in and sign-out, when `allowEmbedding` changes. So over https,
+* delete both. The one left behind would keep the visitor signed in.
+*/
+function expireCookie(name, secure) {
+	if (!secure) return [serializeCookie(name, "", {
+		maxAge: 0,
+		secure
+	})];
+	return [expired(name, false), expired(name, true)];
+}
+/**
+* The deletion of the copy the other mode would write. Sent with a new cookie,
+* so a copy from before `allowEmbedding` changed can't be read in its place.
+*/
+function expireOtherCopy(name, secure) {
+	return secure ? [expired(name, !partitions(secure))] : [];
 }
 const USER_TIMEZONE_COOKIE = "user-timezone";
 function readUserTimezone() {
@@ -56,4 +82,4 @@ function writeCookies(cookies) {
 }
 
 //#endregion
-export { readRequestCookies, readUserTimezone, serializeCookie, writeCookies };
+export { expireCookie, expireOtherCopy, readRequestCookies, readUserTimezone, serializeCookie, writeCookies };