@wix/origami-site 0.1.17 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-site",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Runs an exported Wix origami site: file-based routing, Wix dynamic pages, popups and build checks. Use with @wix/origami-site-astro or @wix/origami-site-express.",
   "type": "module",
   "files": [
@@ -48,7 +48,7 @@
     "@wix/origami-types": "1.4.0",
     "@wix/builder-error-pages": "^1.1.6",
     "@wix/builder-piler-components": "^1.6.7",
-    "@wix/origami-transforms": "0.1.10",
+    "@wix/origami-transforms": "0.1.11",
     "@babel/parser": "^7.25.0",
     "@wix/system-core-components": "^1.3.10"
   },
@@ -91,5 +91,5 @@
       "optional": true
     }
   },
-  "falconPackageHash": "fee6097e759f022daaec303620c3fb7c3e01ac7ae1c727ce992a7f88"
+  "falconPackageHash": "0c04ba80f9a2e61581387449cc08422f3616a50308d1d5691f31751f"
 }

package/src/build/pageList.js

@@ -4,7 +4,8 @@ const resolvedId = `\0${publicId}`
 /** @param {import('@wix/origami-types').SiteRouteTable} table */
 function moduleSource(table) {
     // itemPath is relative to src/ and already includes the pages/ prefix.
-    const entries = [...table.pages, table.notFound].map(page => {
+    // Role pages too: the router decides on the server which one the browser loads.
+    const entries = [...table.pages, ...table.routers.flatMap(router => Object.values(router.rolePages)), table.notFound].map(page => {
         const entry = page.itemPath
             ? `/src/${page.itemPath}/_generated/index.jsx`
             : '@wix/origami-site/default-error-404'

package/src/server/index.d.ts

@@ -9,7 +9,7 @@ export type SiteOptions = {
   mode: 'dev' | 'prod'
   table?: SiteRouteTable                 // prod: the table from the build. dev: omitted, the core scans.
   wix: { clientId: string; siteId: string }   // from VITE_WIX_CLIENT_ID / VITE_WIX_METASITE_ID
-  tokens?: TokenProvider             // default: rejects until router support (stage 2)
+  tokens?: TokenProvider             // default: builderAuthTokenProvider(wix)
   access?: AccessSource              // default: noAccessRules (4)
   accessHandlers?: AccessHandler[]   // default: []
   fetch?: typeof fetch               // tests inject a fake
@@ -70,8 +70,9 @@ export interface AccessHandler {
 }
 
 
-export { SiteTreeError } from './requests/errors.js'
-export type { RouterServiceError } from './requests/errors.js'
+export { SiteTreeError, RouterServiceError } from './requests/errors.js'
+/** The default TokenProvider: the visitor's builder-auth cookie when fresh, else a one-off anonymous token. Stores nothing. */
+export function builderAuthTokenProvider(options: { clientId: string; siteId: string; wixApiBaseUrl?: string; fetch?: typeof fetch; timeoutMs?: number }): TokenProvider
 export function createSite(options: SiteOptions): Promise<OrigamiSite>
 export function readSiteTree(root: string): Promise<SiteRouteTable>
 export function runInRequestContext<T>(ctx: RequestContext, fn: () => Promise<T>): Promise<T>

package/src/server/index.js

@@ -1,6 +1,7 @@
 export { readSiteTree } from './site-tree/readSiteTree.js'
 export { writeBuiltTable, readBuiltTable } from './site-tree/builtTable.js'
-export { SiteTreeError } from './requests/errors.js'
+export { SiteTreeError, RouterServiceError } from './requests/errors.js'
+export { builderAuthTokenProvider } from './tokens/builderAuthTokenProvider.js'
 export { createSite, noAccessRules } from './requests/createSite.js'
 export { runInRequestContext, getRequestContext, getAccessToken } from './requests/context.js'
 export { serializePageData } from './requests/pageData.js'

package/src/server/requests/createSite.js

@@ -1,32 +1,51 @@
 import { createSiteTree } from '../site-tree/createSiteTree.js'
 import { readSiteTree } from '../site-tree/readSiteTree.js'
-import { SiteTreeError } from './errors.js'
+import { callRouter } from '../router/index.js'
+import { pickRolePage } from '../router/pickRolePage.js'
+import { builderAuthTokenProvider } from '../tokens/builderAuthTokenProvider.js'
+import { RouterServiceError, SiteTreeError } from './errors.js'
 import { normalizeRequestPath } from './urlPath.js'
 import { canBePagePath } from './canBePagePath.js'
-import { runInRequestContext } from './context.js'
+import { getAccessToken, runInRequestContext } from './context.js'
 import { errorPage } from './errorPage.js'
 
 /** @type {import('../index.js').AccessSource} */
 export const noAccessRules = { async load() { return new Map() } }
-const unavailableTokens = { async getAccessToken() { throw new Error('Default access tokens are not available until router support.') } }
 const defaultLogger = {
     warn: (...args) => console.warn('[origami]', ...args),
     error: (...args) => console.error('[origami]', ...args),
 }
+/** @param {import('@wix/origami-types').SiteRouteTable} table */
+const rolePagesOf = table => table.routers.flatMap(router => Object.values(router.rolePages))
 
 /** @param {import('../index.js').SiteOptions} options @returns {Promise<import('../index.js').OrigamiSite>} */
 export async function createSite(options) {
-    const { root, mode, access = noAccessRules, accessHandlers = [], tokens = unavailableTokens, logger = defaultLogger } = options
+    const {
+        root, mode, wix, access = noAccessRules, accessHandlers = [], logger = defaultLogger, fetch = globalThis.fetch,
+        wixApiBaseUrl = 'https://www.wixapis.com', routerTimeoutMs = 5000,
+    } = options
+    const tokens = options.tokens ?? builderAuthTokenProvider({ clientId: wix.clientId, siteId: wix.siteId, wixApiBaseUrl, fetch })
+    /** Fail closed: a rule with no handler stops the site instead of serving the page open.
+     * @param {{ itemPath: string, access: import('@wix/origami-types').AccessRule[] }} route */
+    const handlerFor = (route, rule) => {
+        const handler = accessHandlers.find(candidate => candidate.type === rule.type)
+        if (!handler) throw new SiteTreeError('UNSUPPORTED_ACCESS_RULE', [route.itemPath], `No access handler for rule type "${rule.type}".`)
+        return handler
+    }
     /** @param {import('@wix/origami-types').SiteRouteTable} table */
     async function prepare(table) {
         const rules = await access.load(table, root)
-        const pages = table.pages.map(page => ({ ...page, access: rules.get(page.key) ?? page.access }))
-        for (const page of pages) for (const rule of page.access) {
-            if (!accessHandlers.some(handler => handler.type === rule.type)) {
-                throw new SiteTreeError('UNSUPPORTED_ACCESS_RULE', [page.itemPath], `No access handler for rule type "${rule.type}".`)
-            }
+        const withRules = route => ({ ...route, access: rules.get(route.key) ?? route.access })
+        const prepared = {
+            ...table,
+            pages: table.pages.map(withRules),
+            routers: table.routers.map(router => ({
+                ...router,
+                rolePages: Object.fromEntries(Object.entries(router.rolePages).map(([role, page]) => [role, withRules(page)])),
+            })),
         }
-        return { ...table, pages }
+        for (const route of [...prepared.pages, ...rolePagesOf(prepared)]) for (const rule of route.access) handlerFor(route, rule)
+        return prepared
     }
     const tree = mode === 'dev' ? createSiteTree(root, prepare) : null
     const productionTable = tree ? null : await prepare(options.table ?? await readSiteTree(root))
@@ -43,7 +62,59 @@ export async function createSite(options) {
         if (path === undefined) return { kind: 'notFound' }
         if (path === '/_origami' || path.startsWith('/_origami/')) return { kind: 'reserved', path }
         const route = current.pages.find(page => page.url === path)
-        return route ? { kind: 'page', route } : { kind: 'notFound' }
+        if (route) return { kind: 'page', route }
+        // The bare prefix and every path below it go to the router: /team, /team/john, /team/a/b/c.
+        const [, prefix, ...rest] = path.split('/')
+        const router = current.routers.find(candidate => candidate.prefix === prefix)
+        return router ? { kind: 'router', route: router, suffix: `/${rest.join('/')}` } : { kind: 'notFound' }
+    }
+    /** @param {{ itemPath: string, access: import('@wix/origami-types').AccessRule[] }} route @param {Request} request @param {import('../index.js').RequestContext} context */
+    async function checkAccess(route, request, context) {
+        for (const rule of route.access) {
+            const response = await handlerFor(route, rule).check(rule, request, context)
+            if (response) return { kind: /** @type {const} */ ('response'), response }
+        }
+    }
+    /** @param {{ key: string, title: string, itemPath?: string }} route @param {200 | 404} status
+     * @param {import('../index.js').PageData['route']} routeData @param {Record<string, unknown>} services @param {HeadersInit} [headers] */
+    function pageResolution(route, status, routeData, services = {}, headers = {}) {
+        const page = { key: route.key, title: route.title, ...(route.itemPath === undefined ? {} : { itemPath: route.itemPath }) }
+        return { kind: /** @type {const} */ ('page'), status, page, data: { page: page.key, route: routeData, services }, headers: new Headers(headers) }
+    }
+    /** @param {Extract<import('../index.js').RouteMatch, { kind: 'router' }>} match @param {URL} url @param {string} path */
+    async function resolveRouter(match, url, path, current, request, context) {
+        // Answers differ per visitor, so nothing on a router path may be cached, including its 404 and redirects.
+        const noStore = { 'cache-control': 'private, no-store' }
+        let token
+        try { token = await getAccessToken() } catch (error) { return errorPage(error, 503, mode, logger) }
+        let answer
+        try {
+            answer = await callRouter({ router: match.route, suffix: match.suffix, url, token, wixApiBaseUrl, timeoutMs: routerTimeoutMs, fetch })
+        } catch (error) {
+            if (error instanceof RouterServiceError) return errorPage(error, 503, mode, logger)
+            throw error
+        }
+        if (answer.kind === 'redirect') {
+            return { kind: /** @type {const} */ ('response'), response: new Response(null, { status: answer.status, headers: { ...noStore, location: answer.location } }) }
+        }
+        const rolePage = answer.kind === 'page' ? pickRolePage(match.route, answer.page) : null
+        if (answer.kind === 'page' && !rolePage)
+            logger.warn(`The router for /${match.route.prefix} answered page "${answer.page}", which no role page in route.json matches.`)
+        if (answer.kind !== 'page' || !rolePage) return pageResolution(current.notFound, 404, { kind: 'notFound', url: path }, {}, noStore)
+        const denied = await checkAccess(rolePage, request, context)
+        if (denied) {
+            // A login redirect is per visitor too. Copy into new headers: Response.redirect()'s are immutable.
+            const headers = new Headers(denied.response.headers)
+            if (!headers.has('cache-control')) headers.set('cache-control', noStore['cache-control'])
+            const { status, statusText, body } = denied.response
+            return { kind: /** @type {const} */ ('response'), response: new Response(body, { status, statusText, headers }) }
+        }
+        const externalBaseUrl = url.origin
+        return pageResolution(rolePage, 200, { kind: 'router', url: path, role: rolePage.role }, {
+            '@wix/viewer-service-dynamic-route': { dynamicRouteData: { pageData: answer.data, publicData: answer.publicData } },
+            '@wix/site-service-url': { externalBaseUrl },
+            '@wix/viewer-service-url': { externalBaseUrl },
+        }, noStore)
     }
     return {
         table,
@@ -70,22 +141,13 @@ export async function createSite(options) {
                         current = await table()
                         match = matchPath(path, current)
                     }
+                    if (match.kind === 'router') return await resolveRouter(match, url, /** @type {string} */ (path), current, request, context)
                     if (match.kind === 'page') {
-                        for (const rule of match.route.access) {
-                            const handler = accessHandlers.find(candidate => candidate.type === rule.type)
-                            if (!handler) throw new SiteTreeError('UNSUPPORTED_ACCESS_RULE', [match.route.itemPath], `No access handler for rule type "${rule.type}".`)
-                            const response = await handler.check(rule, request, context)
-                            if (response) return { kind: 'response', response }
-                        }
-                    }
-                    const found = match.kind === 'page'
-                    const route = match.kind === 'page' ? match.route : current.notFound
-                    const page = { key: route.key, title: route.title, ...(route.itemPath === undefined ? {} : { itemPath: route.itemPath }) }
-                    return {
-                        kind: 'page', status: found ? 200 : 404, page,
-                        data: { page: page.key, route: { kind: found ? 'page' : 'notFound', url: path ?? url.pathname }, services: {} },
-                        headers: new Headers(),
+                        const denied = await checkAccess(match.route, request, context)
+                        if (denied) return denied
+                        return pageResolution(match.route, 200, { kind: 'page', url: /** @type {string} */ (path) })
                     }
+                    return pageResolution(current.notFound, 404, { kind: 'notFound', url: path ?? url.pathname })
                 })
             } catch (error) { return errorPage(error, 500, mode, logger) }
         },

package/src/server/requests/errors.d.ts

@@ -1,11 +1,11 @@
 export class SiteTreeError extends Error {
   code:
-    | 'NOT_SUPPORTED_YET'                // router pages are not supported in stage 1
     | 'DUPLICATE_URL'                    // two folders give the same URL
     | 'ROUTE_JSON_INVALID'               // not JSON, or a required field missing or of the wrong type
     | 'ROUTE_JSON_MISSING_SERVICE_URL'   // no routerServiceUrl: origami refuses to start
     | 'ROUTE_JSON_SIBLINGS_DIFFER'       // [a]/route.json and [b]/route.json differ
     | 'ROLE_FOLDER_MISSING'              // pages.member = 'team-member' but no [team-member]/ folder
+    | 'ROLE_PAGE_HAS_NO_FILES'           // [x]/ has a route.json but no page files
     | 'ROLE_FOLDER_NOT_IN_PAGES'         // a [x]/ folder that no role in pages names
     | 'BRACKET_OUTSIDE_PREFIX'           // [x]/ not directly under a prefix folder
     | 'PREFIX_HAS_FILES'                 // team/ itself holds page files
@@ -19,6 +19,7 @@ export class SiteTreeError extends Error {
 }
 
 export class RouterServiceError extends Error {
+  constructor(code: RouterServiceError['code'], routerPrefix: string, message: string, details?: { status?: number; cause?: unknown })
   code: 'TIMEOUT' | 'NETWORK' | 'HTTP_STATUS' | 'BAD_RESPONSE'
   routerPrefix: string
   status?: number

package/src/server/requests/errors.js

@@ -11,3 +11,19 @@ export class SiteTreeError extends Error {
         this.paths = [...paths]
     }
 }
+
+export class RouterServiceError extends Error {
+    /**
+     * @param {import('./errors.js').RouterServiceError['code']} code
+     * @param {string} routerPrefix
+     * @param {string} message
+     * @param {{ status?: number, cause?: unknown }} [details]
+     */
+    constructor(code, routerPrefix, message, { status, cause } = {}) {
+        super(`RouterServiceError ${code} for /${routerPrefix}: ${message}`, { cause })
+        this.name = 'RouterServiceError'
+        this.code = code
+        this.routerPrefix = routerPrefix
+        if (status !== undefined) this.status = status
+    }
+}

package/src/server/router/index.js

@@ -0,0 +1,17 @@
+import { RouterServiceError } from '../requests/errors.js'
+import { readRouterAnswer, routerRequest } from './protocol.js'
+
+/** One router call. Never cached and never retried: answers differ per visitor, and a POST isn't safe to repeat.
+ * @param {{ router: import('@wix/origami-types').RouterRoute, suffix: string, url: URL, token: string,
+ *   wixApiBaseUrl: string, timeoutMs: number, fetch: typeof fetch }} options */
+export async function callRouter({ fetch, timeoutMs, ...options }) {
+    const { prefix } = options.router
+    let response
+    try {
+        response = await fetch(routerRequest(options), { signal: AbortSignal.timeout(timeoutMs) })
+    } catch (cause) {
+        const timedOut = cause instanceof DOMException && cause.name === 'TimeoutError'
+        throw new RouterServiceError(timedOut ? 'TIMEOUT' : 'NETWORK', prefix, timedOut ? `no answer within ${timeoutMs} ms` : 'the request failed', { cause })
+    }
+    return readRouterAnswer(response, prefix)
+}

package/src/server/router/pickRolePage.js

@@ -0,0 +1,6 @@
+/** Today the services answer with a Wix page id (route.json pageIds); later with the role itself. One lookup covers both.
+ * @param {import('@wix/origami-types').RouterRoute} router @param {string} resultPage */
+export function pickRolePage(router, resultPage) {
+    if (Object.hasOwn(router.rolePages, resultPage)) return router.rolePages[resultPage]
+    return Object.values(router.rolePages).find(page => page.pageId === resultPage) ?? null
+}

package/src/server/router/protocol.js

@@ -0,0 +1,44 @@
+// The Wix router service protocol, in one file: a change the router teams ask for is a change here.
+// Piler parity (wix-next builder-utils routerUtils.ts), except that roleVariations is really sent.
+import { RouterServiceError } from '../requests/errors.js'
+
+/** @param {{ router: import('@wix/origami-types').RouterRoute, suffix: string, url: URL, token: string, wixApiBaseUrl: string }} options */
+export function routerRequest({ router, suffix, url, token, wixApiBaseUrl }) {
+    const { config } = router
+    const pageRoles = Object.fromEntries(Object.values(router.rolePages).map(page =>
+        [page.role, { id: page.pageId ?? page.role, title: page.title }]))
+    return new Request(new URL(`${config.routerServiceUrl}/pages`, wixApiBaseUrl), {
+        method: 'POST',
+        // The raw token, no "Bearer", as piler sent it.
+        headers: { 'content-type': 'application/json', authorization: token },
+        body: JSON.stringify({
+            routerPrefix: `/${router.prefix}`,
+            fullUrl: `${url.protocol}//${url.host}${url.pathname}`,
+            routerSuffix: suffix,
+            config: config.config,
+            pageRoles,
+            roleVariations: config.roleVariations,
+            requestInfo: { env: 'browser', formFactor: 'desktop' },
+        }),
+    })
+}
+
+/** @typedef {{ kind: 'page', page: string, data: unknown, publicData: unknown } | { kind: 'notFound' } | { kind: 'redirect', status: 301 | 302, location: string }} RouterAnswer */
+
+/** @param {Response} response @param {string} routerPrefix @returns {Promise<RouterAnswer>} */
+export async function readRouterAnswer(response, routerPrefix) {
+    if (!response.ok) throw new RouterServiceError('HTTP_STATUS', routerPrefix, `the router answered HTTP ${response.status}`, { status: response.status })
+    let body
+    try { body = await response.json() } catch (cause) { throw new RouterServiceError('BAD_RESPONSE', routerPrefix, 'the body is not JSON', { cause }) }
+    const result = body?.result
+    if (typeof result !== 'object' || result === null) throw new RouterServiceError('BAD_RESPONSE', routerPrefix, 'the body has no "result"')
+    if (result.status === 200 && typeof result.page === 'string') return { kind: 'page', page: result.page, data: result.data ?? {}, publicData: result.publicData ?? {} }
+    if ((result.status === 301 || result.status === 302) && typeof result.redirectUrl === 'string') {
+        try { new Headers({ location: result.redirectUrl }) } catch (cause) {
+            throw new RouterServiceError('BAD_RESPONSE', routerPrefix, 'redirectUrl is not a valid Location header', { cause })
+        }
+        return { kind: 'redirect', status: result.status, location: result.redirectUrl }
+    }
+    if (result.status === 404) return { kind: 'notFound' }
+    throw new RouterServiceError('BAD_RESPONSE', routerPrefix, `unexpected result status ${JSON.stringify(result.status)}`)
+}

package/src/server/site-tree/readSiteTree.js

@@ -1,9 +1,10 @@
 // Ported from origami-site-runtime/routing/pagesToRoutes.js for the layout 2 tree.
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { basename, resolve } from 'node:path'
+import { basename, dirname, resolve } from 'node:path'
 import { parse } from '@babel/parser'
 import { findItems, pageUrl } from '@wix/origami-types'
 import { SiteTreeError } from '../requests/errors.js'
+import { canonicalJson, readRouteJson } from './routeJson.js'
 
 /** @type {Map<string, { mtimeMs: number, metadata: { title?: string, pageId?: string } }>} */
 const metadataCache = new Map()
@@ -60,6 +61,63 @@ export const siteRoot = root => {
     return resolve(root)
 }
 
+const isBracket = name => /^\[[^[\]]+\]$/.test(name)
+const isPageFolder = entry => entry.isDirectory() && !entry.name.startsWith('.') && !['_generated', 'node_modules'].includes(entry.name)
+const hasPageFiles = entries => entries.some(entry => entry.isFile() && !entry.name.startsWith('.'))
+
+/** A router prefix: `pages/<prefix>/` with only `[slug]` role page folders, each with an identical route.json.
+ * @returns {import('@wix/origami-types').RouterRoute} */
+function readRouter(folder, itemPath, entries) {
+    const path = `src/${itemPath}`
+    const children = entries.filter(isPageFolder)
+    const prefix = basename(folder)
+    if (itemPath.split('/').length !== 2 || /^\(.*\)$/.test(prefix))
+        throw new SiteTreeError('BRACKET_OUTSIDE_PREFIX', children.filter(child => isBracket(child.name)).map(child => `${path}/${child.name}`),
+            'A [page] folder must sit directly in a router prefix folder at the top of src/pages, e.g. src/pages/team/[team-member].')
+    if (entries.some(entry => entry.name === 'route.json'))
+        throw new SiteTreeError('ROUTE_JSON_INVALID', [`${path}/route.json`], `route.json belongs in each [page] folder of /${prefix}, not in the prefix folder.`)
+    if (hasPageFiles(entries))
+        throw new SiteTreeError('PREFIX_HAS_FILES', [path], `The router prefix folder "${prefix}" holds only [page] folders; the Wix router answers /${prefix} itself.`)
+    const others = children.filter(child => !isBracket(child.name))
+    if (others.length)
+        throw new SiteTreeError('PREFIX_COLLIDES_WITH_PAGE', others.map(child => `${path}/${child.name}`), `Every URL under /${prefix} goes to the Wix router, so it can't hold other pages.`)
+    /** @type {{ slug: string, itemPath: string, path: string, config: import('@wix/origami-types').RouteConfig, title: string }[]} */
+    const roleFolders = []
+    for (const child of children) {
+        const childPath = `${path}/${child.name}`
+        const childFolder = resolve(folder, child.name)
+        const childEntries = readdirSync(childFolder, { withFileTypes: true })
+        const nested = childEntries.filter(isPageFolder)
+        if (nested.length) throw new SiteTreeError('ROLE_PAGE_HAS_CHILDREN', nested.map(entry => `${childPath}/${entry.name}`), 'A [page] folder cannot hold other pages.')
+        if (!childEntries.some(entry => entry.name === 'route.json'))
+            throw new SiteTreeError('ROUTE_JSON_INVALID', [`${childPath}/route.json`], 'Every [page] folder of a router needs its route.json.')
+        // Without them the browser would import a page entry that doesn't exist, once the router picks this page.
+        if (!hasPageFiles(childEntries.filter(entry => entry.name !== 'route.json')))
+            throw new SiteTreeError('ROLE_PAGE_HAS_NO_FILES', [childPath], 'This [page] folder has a route.json but no page files.')
+        roleFolders.push({
+            slug: child.name.slice(1, -1), itemPath: `${itemPath}/${child.name}`, path: childPath,
+            config: readRouteJson(resolve(childFolder, 'route.json'), `${childPath}/route.json`),
+            title: pageMetadata(childFolder).title,
+        })
+    }
+    const [first] = roleFolders
+    const differ = roleFolders.find(folder => canonicalJson(folder.config) !== canonicalJson(first.config))
+    if (differ) throw new SiteTreeError('ROUTE_JSON_SIBLINGS_DIFFER', [`${first.path}/route.json`, `${differ.path}/route.json`],
+        'Role pages of one router must have identical route.json files.')
+    const { config } = first
+    const unnamed = roleFolders.filter(folder => !Object.values(config.pages).includes(folder.slug))
+    if (unnamed.length) throw new SiteTreeError('ROLE_FOLDER_NOT_IN_PAGES', unnamed.map(folder => folder.path), 'No role in route.json "pages" names this folder.')
+    /** @type {Record<string, import('@wix/origami-types').RolePage>} */
+    const rolePages = {}
+    for (const [role, slug] of Object.entries(config.pages)) {
+        const folder = roleFolders.find(candidate => candidate.slug === slug)
+        if (!folder) throw new SiteTreeError('ROLE_FOLDER_MISSING', [`${path}/[${slug}]`], `route.json names the "${role}" page "${slug}", but there is no [${slug}] folder.`)
+        const pageId = config.pageIds?.[role]
+        rolePages[role] = { key: folder.itemPath, role, slug, itemPath: folder.itemPath, title: folder.title, access: [], ...(pageId ? { pageId } : {}) }
+    }
+    return { key: itemPath, prefix, config, rolePages }
+}
+
 /** @param {string} root @returns {Promise<import('@wix/origami-types').SiteRouteTable>} */
 export const readSiteTree = async root => {
     const src = resolve(siteRoot(root), 'src')
@@ -68,11 +126,23 @@ export const readSiteTree = async root => {
     /** @type {import('@wix/origami-types').SiteNotFoundRoute} */
     let notFound = { key: '@wix/origami-site/default-error-404', title: 'Page not found' }
     const pathsByUrl = new Map()
-    const { items, routers } = existsSync(resolve(src, 'pages'))
+    const { items, routers: routerPaths } = existsSync(resolve(src, 'pages'))
         ? findItems(path => readdirSync(resolve(src, path), { withFileTypes: true }), 'pages')
         : { items: [], routers: [] }
-    if (routers.length) throw new SiteTreeError('NOT_SUPPORTED_YET', [`src/${routers[0]}`], 'Router pages are not supported yet.')
+    /** @type {import('@wix/origami-types').RouterRoute[]} */
+    const routers = []
+    const prefixes = new Set(routerPaths.filter(path => isBracket(basename(path))).map(path => dirname(path)))
+    for (const prefix of prefixes) {
+        if (prefix === 'pages/error404')
+            throw new SiteTreeError('NOT_FOUND_HAS_CHILDREN', [`src/${prefix}`], 'The not-found page cannot have children.')
+        routers.push(readRouter(resolve(src, prefix), prefix, readdirSync(resolve(src, prefix), { withFileTypes: true })))
+    }
+    for (const path of routerPaths.filter(path => basename(path) === 'route.json')) {
+        if (!routers.some(router => Object.values(router.rolePages).some(page => path === `${page.itemPath}/route.json`)))
+            throw new SiteTreeError('ROUTE_JSON_INVALID', [`src/${path}`], 'route.json belongs in a [page] folder of a router prefix.')
+    }
     for (const itemPath of items) {
+        if (routers.some(router => Object.values(router.rolePages).some(page => page.itemPath === itemPath))) continue
         const path = `src/${itemPath}`
         const metadata = pageMetadata(resolve(src, itemPath))
         if (itemPath === 'pages/error404') notFound = { key: itemPath, itemPath, title: metadata.title }
@@ -88,5 +158,10 @@ export const readSiteTree = async root => {
     if (notFoundChildren.length)
         throw new SiteTreeError('NOT_FOUND_HAS_CHILDREN', ['src/pages/error404', ...notFoundChildren.map(page => `src/${page.itemPath}`)],
             'The not-found page cannot have children.')
-    return { version: 2, pages, routers: [], notFound, popups: [] }
+    for (const router of routers) {
+        const page = pages.find(candidate => candidate.url === `/${router.prefix}` || candidate.url.startsWith(`/${router.prefix}/`))
+        if (page) throw new SiteTreeError('PREFIX_COLLIDES_WITH_PAGE', [`src/${router.key}`, `src/${page.itemPath}`],
+            `Every URL under /${router.prefix} goes to the Wix router, so "${page.url}" can't be a page.`)
+    }
+    return { version: 2, pages, routers, notFound, popups: [] }
 }

package/src/server/site-tree/routeJson.js

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs'
+import { SiteTreeError } from '../requests/errors.js'
+
+const isRecord = value => typeof value === 'object' && value !== null && !Array.isArray(value)
+const isStringRecord = value => isRecord(value) && Object.values(value).every(item => typeof item === 'string' && item !== '')
+
+/** Reads and checks one route.json. The core reads only routerServiceUrl, pages and pageIds; the rest passes through.
+ * @param {string} file absolute path @param {string} path site-relative path for errors
+ * @returns {import('@wix/origami-types').RouteConfig} */
+export function readRouteJson(file, path) {
+    let config
+    try { config = JSON.parse(readFileSync(file, 'utf8')) } catch (error) {
+        throw new SiteTreeError('ROUTE_JSON_INVALID', [path], `Not valid JSON: ${/** @type {Error} */ (error).message}`)
+    }
+    const invalid = message => new SiteTreeError('ROUTE_JSON_INVALID', [path], message)
+    if (!isRecord(config)) throw invalid('route.json must hold a JSON object.')
+    if (typeof config.routerServiceUrl !== 'string' || !config.routerServiceUrl)
+        throw new SiteTreeError('ROUTE_JSON_MISSING_SERVICE_URL', [path], 'route.json has no routerServiceUrl, so the Wix router cannot be called. Export the site again.')
+    if (!isStringRecord(config.pages) || !Object.keys(config.pages).length) throw invalid('"pages" must map each role to its page folder name, e.g. { "member": "team-member" }.')
+    if (config.pageIds !== undefined && !isStringRecord(config.pageIds)) throw invalid('"pageIds" must map each role to a Wix page id.')
+    if (!('config' in config)) throw invalid('"config" is missing.')
+    if (!isRecord(config.roleVariations)) throw invalid('"roleVariations" must be an object.')
+    return config
+}
+
+/** Key order and whitespace don't count when siblings are compared. */
+export const canonicalJson = value => JSON.stringify(value, (_key, item) =>
+    isRecord(item) ? Object.fromEntries(Object.keys(item).sort().map(key => [key, item[key]])) : item)

package/src/server/tokens/builderAuthTokenProvider.js

@@ -0,0 +1,34 @@
+// Cookie names from @wix/builder-auth (constants.ts, tokenStore.ts): scoped by `_${siteId}`, expiry in epoch ms.
+const cookie = (header, name) => {
+    for (const part of (header ?? '').split(';')) {
+        const index = part.indexOf('=')
+        if (index > 0 && part.slice(0, index).trim() === name) {
+            try { return decodeURIComponent(part.slice(index + 1).trim()) } catch { return undefined }
+        }
+    }
+}
+
+/** The visitor's own builder-auth token when the cookie is there and fresh; otherwise a one-off anonymous token.
+ * Stores nothing and sets no cookie: builder-auth in the browser keeps owning the visitor's tokens.
+ * @param {{ clientId: string, siteId: string, wixApiBaseUrl?: string, fetch?: typeof fetch, timeoutMs?: number }} options
+ * @returns {import('../index.js').TokenProvider} */
+export function builderAuthTokenProvider({ clientId, siteId, wixApiBaseUrl = 'https://www.wixapis.com', fetch = globalThis.fetch, timeoutMs = 5000 }) {
+    return {
+        async getAccessToken(request) {
+            const header = request.headers.get('cookie')
+            const token = cookie(header, `wix_access_token_${siteId}`)
+            const expiresAt = Number(cookie(header, `wix_token_expires_at_${siteId}`))
+            if (token && expiresAt > Date.now()) return token
+            if (!clientId) throw new Error('VITE_WIX_CLIENT_ID is not set, so there is no visitor token for the Wix router.')
+            const response = await fetch(new URL('/oauth2/token', wixApiBaseUrl), {
+                method: 'POST', headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ client_id: clientId, grant_type: 'anonymous' }),
+                signal: AbortSignal.timeout(timeoutMs),
+            })
+            if (!response.ok) throw new Error(`The anonymous token request answered HTTP ${response.status}.`)
+            const { access_token: accessToken } = await response.json()
+            if (typeof accessToken !== 'string' || !accessToken) throw new Error('The anonymous token response has no access_token.')
+            return accessToken
+        },
+    }
+}