@sevenfold/setto-client 0.4.0 → 0.6.0

package/README.md

@@ -8,29 +8,29 @@ Editors authenticate via Supabase, edit text inline on the live page, pick secti
 
 ## Install
 
-```bash
-bun add @setto/client@npm:@sevenfold/setto-client
-```
-
-Or add directly to `package.json`:
+Sevenfold sites pin an npm version via alias:
 
 ```json
-"@setto/client": "npm:@sevenfold/setto-client@^0.1.0"
+"@setto/client": "npm:@sevenfold/setto-client@0.5.0"
 ```
 
-Peer deps: `react`, `react-dom`, `react-i18next`, `i18next`.
+`bun install` pulls the prebuilt package from npm — no GitHub token required on Vercel.
 
-For local monorepo development alongside `carryon.no`, a `file:` link also works — see [Local development](#local-development-sevenfold-monorepo).
+Peer deps: `react`, `react-dom`, `react-i18next`, `i18next`.
 
-### Publishing a new version
+For local monorepo development the consumer's `vite.config.ts` aliases `@setto/client` to setto-client source — see [Local development](#local-development-sevenfold-monorepo).
 
-1. Bump `version` in `package.json`
-2. Commit and push a tag: `git tag v0.1.1 && git push origin v0.1.1`
-3. GitHub Actions publishes to npm automatically
+### Releasing a new version
 
-Requires an `NPM_TOKEN` secret in the GitHub repo (Granular Access Token from npmjs.com with write access to `@sevenfold`).
+1. Bump `version` in `package.json` following semver (patch / minor / major).
+2. Commit and push to `main`. GitHub Actions publishes `@sevenfold/setto-client` to npm automatically (requires `NPM_TOKEN` secret in this repo).
+3. Confirm the version is on npm: `npm view @sevenfold/setto-client@X.Y.Z version`.
+4. In each consumer (`carryon.no`, `setto-site`):
+   - Update the pin in `package.json` (e.g. `@0.5.0` → `@0.5.1`).
+   - Run `bun install` to refresh the lockfile.
+   - Commit and push — Vercel installs the new npm version on the next deploy.
 
-Or trigger manually via **Actions → Publish to npm → Run workflow**.
+> **Why npm, not a git tag?** `nitech/setto-client` is private. Vercel cannot fetch `github:nitech/setto-client#v…` without a `GITHUB_TOKEN` with repo access. Public npm avoids that and ships a prebuilt `dist/`.
 
 ---
 
@@ -69,7 +69,7 @@ createRoot(document.getElementById('root')!).render(
 
 ### 2. Mount the Setto route
 
-Editors reach edit mode by visiting `sitenavn.no/setto`.
+Editors sign in once at `sitenavn.no/setto`. After that, every visit to the public site auto-enters edit mode for as long as the Supabase session persists.
 
 ```tsx
 // App.tsx
@@ -126,24 +126,32 @@ function ValuesSection() {
 
 ## Edit mode
 
-Edit mode activates when **both** are true:
+Edit mode activates whenever **all** of these are true:
 
-1. Authenticated Supabase session.
-2. URL contains `?setto=edit`.
+1. The user has an authenticated Supabase session.
+2. The user has access to `config.siteId` (a row in the `sites` table that they can read).
+3. The current path is not `/setto` (the dashboard is rendered without inline editing).
 
-The `/setto` dashboard does **not** activate edit mode. Use **Begynn å redigere**, which navigates to `/?setto=edit`.
+Sign-in at `/setto` persists via Supabase, so subsequent visits drop straight into edit mode — no URL flag, no extra step.
 
 ### What editors see
 
+A small round Setto button floats in the bottom-right corner. While there are no unpublished changes it stays as a circle showing only the Setto mark. As soon as you edit something it grows into a pill containing **Publiser** and a **⋯** menu with:
+
+| Item | Effect |
+|------|--------|
+| **Avbryt** | Discards every unsaved draft (text, section colours, image uploads) |
+| **Logg ut** | Signs out via Supabase and exits edit mode |
+| **Historikk** | Opens the `/setto` dashboard with deployment history |
+
 | Action | How |
 |--------|-----|
 | Edit text | Click any `<T>` element — it becomes `contentEditable` |
 | Edit section colours | Click a section or block background (not text) |
 | Follow a link | Ctrl/Cmd + click (desktop) · **Naviger ↗** chip when focused (touch) |
-| Publish | Top toolbar → **Publiser** |
-| Exit | Top toolbar → **Avslutt** (removes `?setto=edit`) |
+| Publish | FAB → **Publiser** (visible once you have drafts) |
 
-A fixed toolbar sits at the top of the viewport. When you click a section or block, a compact colour toolbar appears above it, centred and sized to its contents. Click again or press Escape to dismiss.
+When you click a section or block, a compact colour toolbar appears above it. Click again or press Escape to dismiss.
 
 ---
 
@@ -308,7 +316,7 @@ Keeping this in the repo means content shape lives with the code that defines it
 
 ## Publish flow
 
-1. Editor clicks **Publiser** in the top toolbar.
+1. Editor clicks **Publiser** in the floating FAB.
 2. Client serialises changed locale bundles + `sections.json` (if theme drafts exist).
 3. `POST /sites/:siteId/publish` with `{ files: [{ path, content }] }`.
 4. setto-server validates paths against `content_paths`, commits to GitHub.
@@ -322,7 +330,7 @@ Drafts are cleared after a successful publish.
 
 Route: `/setto/*`
 
-Provides Supabase email/password login (invite-only — no self-service sign-up), password reset, and a dashboard with a link to start editing (`/?setto=edit`). Invite links from Supabase land on `/setto` to set a password. Does not render the inline editor itself.
+Provides Supabase email/password login (invite-only — no self-service sign-up), password reset, and a dashboard. After sign-in the dashboard redirects to the site home, where edit mode auto-activates. Invite links from Supabase land on `/setto` to set a password. Does not render the inline editor itself.
 
 ---
 

package/dist/SettoAnimation.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from 'react';
+import type { AnimationPreset } from './block-tree/schema';
+export interface SettoAnimationProps {
+    preset: AnimationPreset;
+    /** Delay before play, in milliseconds. */
+    delay?: number;
+    /** Duration in milliseconds. Defaults per preset. */
+    duration?: number;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * Lightweight, CSS-driven reveal wrapper. Triggers once when scrolled into
+ * view (or immediately, for non-scroll presets). Honors
+ * `prefers-reduced-motion`, falls back to plain children with no animation.
+ *
+ * Hosts that use GSAP (carryon.no, setto-site) should keep their own
+ * `data-reveal` system; this primitive exists so generated layout trees
+ * have a portable animation primitive without dragging GSAP into the
+ * setto-client bundle.
+ */
+export declare function SettoAnimation({ preset, delay, duration, className, children, }: SettoAnimationProps): import("react/jsx-runtime").JSX.Element;

package/dist/SettoForm.d.ts

@@ -0,0 +1,18 @@
+import type { FormField } from './block-tree/schema';
+export interface SettoFormProps {
+    /** Scopes i18n keys: `form.{formId}.submit`, `.success`, `.error`. */
+    formId: string;
+    fields: FormField[];
+    /** Static POST endpoint. Either this or `endpointKey` must be provided. */
+    endpoint?: string;
+    /** i18n key whose value is the runtime endpoint URL. */
+    endpointKey?: string;
+    className?: string;
+}
+/**
+ * Generic POST form whose copy lives in i18n. Field structure is fixed by
+ * the host (or by the block tree) — editors can change labels and copy but
+ * not the field set, matching the Setto product principle that the editor
+ * adjusts content, not structure.
+ */
+export declare function SettoForm({ formId, fields, endpoint, endpointKey, className, }: SettoFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/SettoVideo.d.ts

@@ -0,0 +1,16 @@
+export interface SettoVideoProps {
+    /** i18n key holding the video URL (YouTube, Vimeo, or direct MP4). */
+    srcKey: string;
+    /** Optional i18n key holding a poster image URL (HTML5 video only). */
+    posterKey?: string;
+    title?: string;
+    className?: string;
+}
+/**
+ * Renders a video from a URL stored in i18n. YouTube and Vimeo URLs become
+ * iframe embeds; everything else renders as an HTML5 `<video>` element.
+ *
+ * Editors can change the URL via the i18n draft store (a dedicated picker
+ * UI may follow; until then it's swap-via-publish like other content).
+ */
+export declare function SettoVideo({ srcKey, posterKey, title, className }: SettoVideoProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/App.d.ts

@@ -2,10 +2,9 @@
  * Drop-in admin SPA. Mount under a route like `<Route path="/setto/*" .../>`.
  *
  * Behaviour after login:
- *  - Redirects to `/?setto=edit` on the site home (edit mode active).
+ *  - Redirects to the site home `/`. Edit mode activates automatically there
+ *    via `SettoProvider` when the user has access to `config.siteId`.
  *  - Shows the dashboard only when the user lacks access to this site, or on
  *    `/setto?deployment=…` for publish progress / history.
- *
- * Editing happens on the public site at `/?setto=edit`.
  */
 export declare function SettoAdminApp(): import("react/jsx-runtime").JSX.Element;

package/dist/block-tree/SettoBlockTree.d.ts

@@ -0,0 +1,24 @@
+import { type ComponentType } from 'react';
+import { type SettoIconRenderProps } from '../SettoIcon';
+import type { BlockTree } from './schema';
+export interface SettoBlockTreeProps {
+    /** Validated block tree, typically parsed from `home.layout.json`. */
+    tree: BlockTree;
+    /**
+     * Icon registry consumed by `SettoIcon` nodes — the same map a host would
+     * pass directly to `<SettoIcon icons={…}>`.
+     */
+    icons: Record<string, ComponentType<SettoIconRenderProps>>;
+    /**
+     * When true (default), validates the tree and throws on schema errors.
+     * Disable in production after a one-time boot check.
+     */
+    validate?: boolean;
+}
+/**
+ * Renders a block tree by dispatching each node to the matching Setto
+ * primitive. Inside a `repeater`, leaf nodes use keys relative to the item;
+ * the renderer composes them with the active scope so the agent can author
+ * trees without knowing per-item suffixes.
+ */
+export declare function SettoBlockTree({ tree, icons, validate }: SettoBlockTreeProps): import("react/jsx-runtime").JSX.Element;

package/dist/block-tree/extract-keys.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Walks a block tree and reports the i18n keys, theme ids, and required
+ * sample-locale entries it expects. The agent uses this output to validate
+ * that the generated `no.json` covers everything the tree references.
+ */
+import type { BlockTree } from './schema';
+export interface ContentKeyRequirements {
+    /** Plain i18n keys that must exist with a string value. */
+    keys: Set<string>;
+    /**
+     * Section / block theme ids referenced by the tree. The deterministic
+     * sections.json overlay and section-schemas.ts must include each id.
+     */
+    themeIds: Set<string>;
+    /**
+     * Repeater requirements — at least one item entry must exist in the
+     * locale under `itemsKey`, with every field from `defaultItem`.
+     */
+    repeaters: Array<{
+        itemsKey: string;
+        fields: string[];
+        /**
+         * Item-relative keys produced by walking the item template. The
+         * validator checks every existing locale item has these keys.
+         */
+        itemKeys: string[];
+    }>;
+}
+/** Returns content requirements for an already-validated tree. */
+export declare function extractContentKeys(tree: BlockTree): ContentKeyRequirements;

package/dist/block-tree/registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Per-type metadata for block-tree nodes.
+ *
+ * The renderer dispatches on node `type`; the validator and key extractor
+ * consult this registry for allowed children, required content keys, and
+ * whether a type carries a theme id.
+ */
+import type { BlockNode, BlockNodeType } from './schema';
+export interface BlockTypeMeta {
+    /**
+     * Allowed child types. `null` means the node is a leaf; `'any'` means any
+     * other type may appear as a child.
+     */
+    allowedChildren: BlockNodeType[] | 'any' | null;
+    /** True when the node has a theme id (used in `sections.json`). */
+    themed: boolean;
+    /** True when this node participates as a `SectionToolbar` target. */
+    selectable: boolean;
+}
+export declare const BLOCK_REGISTRY: Record<BlockNodeType, BlockTypeMeta>;
+/** All known block types, kept in sync with `BLOCK_REGISTRY`. */
+export declare const BLOCK_TYPES: readonly BlockNodeType[];
+/** Returns the children of a node, or an empty array for leaves. */
+export declare function nodeChildren(node: BlockNode): BlockNode[];

package/dist/block-tree/schema.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Declarative page model rendered by `SettoBlockTree`.
+ *
+ * A site's layout is a tree of typed nodes. Each node maps to one of the
+ * existing editable primitives (T, SettoSection, SettoBlock, SettoRepeater,
+ * SettoImage, SettoIcon) or to a new composite primitive (SettoForm,
+ * SettoVideo, SettoAnimation). The tree is stored as JSON
+ * (`src/content/pages/home.layout.json`) and is what `setto-agent` generates
+ * during onboarding instead of writing TSX.
+ */
+export type BlockTreeVersion = '1';
+export interface BlockTree {
+    version: BlockTreeVersion;
+    /** Top-level nodes rendered into `<main>` (or a host-provided wrapper). */
+    root: BlockNode[];
+}
+export type BlockNode = SectionNode | BlockBoxNode | ContainerNode | TextNode | ImageNode | IconNode | RepeaterNode | FormNode | VideoNode | AnimationNode;
+export type BlockNodeType = BlockNode['type'];
+interface BaseNode {
+    /** Stable id within the tree — used as React key and for diff/edit ops. */
+    id: string;
+    /** Optional Tailwind / CSS class string applied to the rendered element. */
+    className?: string;
+}
+export interface SectionNode extends BaseNode {
+    type: 'section';
+    /** Matches a key in `sections.json` / `sectionSchemas` for background theme. */
+    sectionId: string;
+    children: BlockNode[];
+}
+export interface BlockBoxNode extends BaseNode {
+    type: 'block';
+    blockId: string;
+    children: BlockNode[];
+}
+export type ContainerTag = 'div' | 'section' | 'header' | 'footer' | 'main' | 'aside' | 'nav' | 'article' | 'ul' | 'ol' | 'li' | 'p' | 'span';
+export interface ContainerNode extends BaseNode {
+    type: 'container';
+    tag?: ContainerTag;
+    children: BlockNode[];
+}
+export type TextAs = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'span' | 'div' | 'label' | 'em' | 'strong';
+export interface TextNode extends BaseNode {
+    type: 'text';
+    /** i18n key, or a key relative to the surrounding repeater item. */
+    k: string;
+    /** Element tag to wrap the `<T>` in. Defaults to inline span. */
+    as?: TextAs;
+}
+export interface ImageNode extends BaseNode {
+    type: 'image';
+    /** i18n key holding the image src (resolved at runtime). */
+    srcKey: string;
+    alt?: string;
+}
+export interface IconNode extends BaseNode {
+    type: 'icon';
+    /** i18n key holding the icon name from the host icon registry. */
+    k: string;
+    size?: number;
+}
+export interface RepeaterNode extends BaseNode {
+    type: 'repeater';
+    /** i18n list prefix, e.g. 'faq.items'. */
+    itemsKey: string;
+    /** Norwegian label shown in the editor's add/remove controls. */
+    itemLabel?: string;
+    /** Field defaults seeded into i18n when an editor adds a new item. */
+    defaultItem: Record<string, string>;
+    /**
+     * Subtree rendered once per item. Text/image/icon nodes here may use
+     * keys relative to the item (e.g. `k: 'q'` resolves to
+     * `faq.items.{itemKey}.q` at render time).
+     */
+    itemTemplate: BlockNode[];
+}
+export type FormFieldType = 'text' | 'email' | 'tel' | 'textarea';
+export interface FormField {
+    /** Submitted form field name. */
+    name: string;
+    type: FormFieldType;
+    required?: boolean;
+    /** i18n key for the field label. */
+    labelKey: string;
+    /** i18n key for the placeholder text. */
+    placeholderKey?: string;
+}
+export interface FormNode extends BaseNode {
+    type: 'form';
+    /**
+     * Scopes all i18n keys for this form: `form.{formId}.submit`,
+     * `form.{formId}.success`, `form.{formId}.error`.
+     */
+    formId: string;
+    /** Static POST endpoint. Use `endpointKey` to read from i18n instead. */
+    endpoint?: string;
+    /** i18n key whose value is the form POST endpoint. */
+    endpointKey?: string;
+    fields: FormField[];
+}
+export interface VideoNode extends BaseNode {
+    type: 'video';
+    /** i18n key holding the embed URL (YouTube, Vimeo, MP4, …). */
+    srcKey: string;
+    /** Optional i18n key for a poster image (HTML5 video only). */
+    posterKey?: string;
+    /** Iframe accessibility title. Not editable. */
+    title?: string;
+}
+export type AnimationPreset = 'fadeIn' | 'slideUp' | 'stagger' | 'scrollReveal';
+export interface AnimationNode extends BaseNode {
+    type: 'animation';
+    preset: AnimationPreset;
+    /** Delay before play, in milliseconds. */
+    delay?: number;
+    /** Duration in milliseconds. Defaults to preset value. */
+    duration?: number;
+    children: BlockNode[];
+}
+export {};

package/dist/block-tree/validate.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Runtime validator for block trees.
+ *
+ * Used by both `setto-client` (when loading a `home.layout.json` at boot)
+ * and `setto-agent` (after generation, before sandbox build). No external
+ * dependencies so we can ship to host sites without bundle bloat.
+ */
+import type { BlockTree, FormField } from './schema';
+export interface ValidationIssue {
+    /** Dotted path to the offending node, e.g. `root[2].children[0]`. */
+    path: string;
+    message: string;
+}
+export type ValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    issues: ValidationIssue[];
+};
+/**
+ * Validates a parsed block tree. Returns the first batch of issues found —
+ * the goal is enough detail for a fixer model to act on, not exhaustive
+ * reporting.
+ */
+export declare function validateBlockTree(input: unknown): ValidationResult;
+/** Narrowing helper: validates and returns a typed tree, or throws. */
+export declare function parseBlockTree(input: unknown): BlockTree;
+export type { FormField };

package/dist/edit-mode/constants.d.ts

@@ -1,2 +1,4 @@
-/** Height of the fixed edit toolbar (px). */
-export declare const TOOLBAR_HEIGHT = 44;
+/** Diameter of the collapsed FAB and height of the expanded pill (px). */
+export declare const FAB_SIZE = 52;
+/** Distance from the viewport edges to the FAB (px). */
+export declare const FAB_INSET = 16;

package/dist/edit-mode/document-layout.d.ts

@@ -1,5 +1,7 @@
 /**
- * Reserves space at the top of the viewport for the Setto edit toolbar.
- * The host site keeps full width — only vertical offset is applied.
+ * Applies the document-level CSS for inline edit mode. The fixed top toolbar
+ * has been replaced with a floating FAB anchored bottom-right, so the host
+ * page no longer needs vertical padding — only edit-affordance hover styles
+ * and the portal layers above the page.
  */
 export declare function useSettoDocumentLayout(active: boolean): void;

package/dist/edit-mode/mount.d.ts

@@ -5,8 +5,8 @@ interface EditModeShellProps {
     themeStore: ThemeStore | null;
 }
 /**
- * Edit mode: full-width page with a fixed toolbar at the top. Text is edited
- * inline via contentEditable on `<T>` — no sidebar.
+ * Edit mode: full-width page with a floating Setto FAB anchored bottom-right.
+ * Text is edited inline via contentEditable on `<T>` — no sidebar.
  */
 export declare function EditModeShell({ children, themeStore }: EditModeShellProps): import("react/jsx-runtime").JSX.Element;
 /** @deprecated Use EditModeShell */

package/dist/edit-mode/setto-mark.d.ts

@@ -0,0 +1,16 @@
+import type { CSSProperties } from 'react';
+interface SettoMarkProps {
+    size?: number;
+    /** Color of the "S" letter. Defaults to the Setto crema tone. */
+    letterColor?: string;
+    /** Color of the accent dot. Defaults to the Setto terracotta. */
+    dotColor?: string;
+    style?: CSSProperties;
+}
+/**
+ * Setto brand mark — the foreground of the setto-site favicon (italic "S" with
+ * a terracotta dot) on a transparent background. The FAB renders the dark
+ * Blekk background itself so the mark only carries the glyphs.
+ */
+export declare function SettoMark({ size, letterColor, dotColor, style, }: SettoMarkProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/index.d.ts

@@ -9,9 +9,22 @@ export { SettoImage } from './SettoImage';
 export type { SettoImageProps } from './SettoImage';
 export { SettoRepeater } from './SettoRepeater';
 export type { SettoRepeaterProps } from './SettoRepeater';
+export { SettoForm } from './SettoForm';
+export type { SettoFormProps } from './SettoForm';
+export { SettoVideo } from './SettoVideo';
+export type { SettoVideoProps } from './SettoVideo';
+export { SettoAnimation } from './SettoAnimation';
+export type { SettoAnimationProps } from './SettoAnimation';
 export { useSectionTheme } from './use-section-theme';
 export { SettoAdminApp } from './admin/App';
 export { SETTO_BASE } from './lib/urls';
 export { AuthGate } from './edit-mode/auth-gate';
 export type { SettoConfig, BrandColor, DeploymentRow, SiteRow, ContentFile, PublishFile, PublishResult, } from './types';
 export type { SectionSchema, SectionColorField } from './section-schema';
+export { SettoBlockTree } from './block-tree/SettoBlockTree';
+export type { SettoBlockTreeProps } from './block-tree/SettoBlockTree';
+export type { BlockTree, BlockTreeVersion, BlockNode, BlockNodeType, SectionNode, BlockBoxNode, ContainerNode, ContainerTag, TextNode, TextAs, ImageNode, IconNode, RepeaterNode, FormNode, FormField, FormFieldType, VideoNode, AnimationNode, AnimationPreset, } from './block-tree/schema';
+export { validateBlockTree, parseBlockTree, type ValidationIssue, type ValidationResult, } from './block-tree/validate';
+export { extractContentKeys, type ContentKeyRequirements, } from './block-tree/extract-keys';
+export { BLOCK_REGISTRY, BLOCK_TYPES, nodeChildren } from './block-tree/registry';
+export type { BlockTypeMeta } from './block-tree/registry';

package/dist/lib/theme-store.d.ts

@@ -27,6 +27,8 @@ export declare class ThemeStore {
     set(sectionId: string, field: string, value: string): void;
     /** Replace baseline from GitHub without creating drafts. */
     loadBaseline(next: SectionsTheme): void;
+    /** Resets every draft back to its original value. */
+    revertAll(): void;
     commit(): void;
     size(): number;
     serialise(): SectionsTheme;

package/dist/lib/urls.d.ts

@@ -1,11 +1,15 @@
 /**
  * Base path where the Setto login + dashboard SPA is mounted on the host site.
- * Editors reach edit mode by visiting `sitenavn.no/setto`. The host app must
- * mount `<SettoAdminApp>` at this path (e.g. `<Route path="/setto/*" …>`).
+ * Editors reach the dashboard by visiting `sitenavn.no/setto`. The host app
+ * must mount `<SettoAdminApp>` at this path (e.g. `<Route path="/setto/*" …>`).
  */
 export declare const SETTO_BASE = "/setto";
-/** Site home with inline edit mode active. */
-export declare function editModeUrl(pathname?: string): string;
+/**
+ * Site home URL used after sign-in. Edit mode itself is now driven by the
+ * Supabase session + site access — no URL flag required — so this just sends
+ * the editor to the public site root.
+ */
+export declare function siteHomeUrl(pathname?: string): string;
 export declare function isAdminRoute(): boolean;
 /** Setto deployment progress panel (`/setto?deployment=…`). */
 export declare function isAdminDeploymentView(): boolean;

package/dist/lib/use-site-access.d.ts

@@ -0,0 +1,16 @@
+import type { Session, SupabaseClient } from '@supabase/supabase-js';
+import type { SiteRow } from '../types';
+export interface SiteAccessState {
+    /** All sites the current user can access. `null` until loaded. */
+    sites: SiteRow[] | null;
+    /** The site matching `siteId`, or `null` if the user has no access. */
+    currentSite: SiteRow | null;
+    loading: boolean;
+    error: string | null;
+}
+/**
+ * Loads the sites table for the current Supabase session and resolves whether
+ * the user has access to `siteId`. Returns a stable shape across loading,
+ * success, and failure so callers can read `currentSite` directly.
+ */
+export declare function useSiteAccess(supabase: SupabaseClient, session: Session | null, siteId: string): SiteAccessState;

package/dist/provider.d.ts

@@ -4,7 +4,7 @@ import { type SettoApi } from './lib/api';
 import { I18nStore } from './lib/i18n-store';
 import { AssetStore } from './lib/asset-store';
 import { ThemeStore } from './lib/theme-store';
-import type { SettoConfig } from './types';
+import type { SettoConfig, SiteRow } from './types';
 interface SettoContextValue {
     config: SettoConfig;
     supabase: SupabaseClient;
@@ -12,8 +12,12 @@ interface SettoContextValue {
     session: Session | null;
     /** True while the initial auth state is being read from local storage. */
     authLoading: boolean;
-    /** True when inline edit mode is active (`?setto=edit` + session). */
+    /** True when inline edit mode is active (session + site access). */
     editMode: boolean;
+    /** Site row matching `config.siteId`, or `null` if the user has no access. */
+    currentSite: SiteRow | null;
+    /** All sites the user can access (loaded after sign-in). */
+    sites: SiteRow[] | null;
     /**
      * Lazily created when i18next is initialised. Components that need it
      * should `if (!store) return null;` until then.
@@ -32,10 +36,11 @@ export interface SettoProviderProps {
  *
  * Edit mode is on when ALL of:
  *   1. There is an authenticated Supabase session.
- *   2. The URL contains `?setto=edit`.
+ *   2. The user has access to `config.siteId` in the Setto sites table.
+ *   3. The current path is not the `/setto` admin SPA.
  *
- * The /setto dashboard does not activate edit mode — use "Begynn å redigere"
- * which navigates to `/?setto=edit`.
+ * Once an editor signs in via `/setto`, returning visits auto-enter edit mode
+ * for as long as the Supabase session persists.
  */
 export declare function SettoProvider({ config, children }: SettoProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare function useSetto(): SettoContextValue;