@trypattern/sdk 0.1.9 → 0.1.11

package/dist/server/createServer.js

@@ -2,12 +2,15 @@ import { Hono } from 'hono';
 import { csrf } from 'hono/csrf';
 import { adminEmails } from "../access.js";
 import { appTitle } from "../appTitle.js";
+import { media } from "../media.js";
 import { auth, devSignIn } from "./auth.js";
 import { serveDatabase } from "./database.js";
 import { attachPatternViewer, bearerOf } from "./patternViewer.js";
 import { forgetSession, issuePass, needsRecheck, readPass, rememberUser } from "./session.js";
 import { renewSession } from "./sessions.js";
 import { readTitle, writeTitle } from "./settings.js";
+import { serveMedia, uploadMedia } from "./media.js";
+import { matchPage, renderPage, robots, sitemap, wantsHtml } from "./pages.js";
 import { serveTables } from "./tables.js";
 import { findUser } from "./users.js";
 const PUBLIC_PATHS = ['/api/health', '/api/auth/'];
@@ -47,8 +50,9 @@ async function attachViewer(c, next) {
     });
     return next();
 }
-export function createServer({ tables, admins, routes }) {
+export function createServer({ tables, admins, routes, pages }) {
     const authRoutes = import.meta.env.DEV ? auth.route('/', devSignIn) : auth;
+    const hasMedia = Object.values(tables).some((table) => table === media);
     const server = new Hono()
         .basePath('/api')
         .use(csrf())
@@ -83,6 +87,32 @@ export function createServer({ tables, admins, routes }) {
     })
         .route('/', serveDatabase(tables))
         .route('/tables', serveTables(tables));
+    if (hasMedia)
+        server.post('/media', uploadMedia);
     const own = routes;
-    return (own === undefined ? server : server.route('/', own)).notFound((c) => c.json({ error: `No route for ${c.req.path}` }, 404));
+    const root = new Hono();
+    if (hasMedia)
+        root.get('/media/*', serveMedia);
+    if (pages !== undefined) {
+        root.get('/sitemap.xml', (c) => sitemap(c, pages));
+        root.get('/robots.txt', robots);
+    }
+    return root
+        .route('/', own === undefined ? server : server.route('/', own))
+        .notFound((c) => {
+        if (c.req.path === '/api' || c.req.path.startsWith('/api/')) {
+            return c.json({ error: `No route for ${c.req.path}` }, 404);
+        }
+        const page = pages === undefined || !wantsHtml(c)
+            ? undefined
+            : matchPage(pages, c.req.path);
+        if (page !== undefined && pages !== undefined) {
+            return renderPage(c, pages, page.route, page.params);
+        }
+        const assets = c.env.ASSETS;
+        if (assets === undefined) {
+            return c.json({ error: `No route for ${c.req.path}` }, 404);
+        }
+        return assets.fetch(c.req.raw);
+    });
 }

package/dist/server/env.d.ts

@@ -1,10 +1,12 @@
-import type { D1Database } from '@cloudflare/workers-types';
+import type { D1Database, Fetcher, R2Bucket } from '@cloudflare/workers-types';
 import type { Viewer } from '../access.ts';
 export type { Viewer };
 export type ServerBindings = {
     DB: D1Database;
     SESSION_SECRET: string;
     AUTH_SECRET?: string;
+    MEDIA?: R2Bucket;
+    ASSETS?: Fetcher;
 };
 export type ServerEnv<Bindings extends ServerBindings = ServerBindings> = {
     Bindings: Bindings;

package/dist/server/imageHeader.d.ts

@@ -0,0 +1,10 @@
+export type ImageFormat = {
+    type: 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/avif';
+    extension: 'jpg' | 'png' | 'webp' | 'gif' | 'avif';
+};
+export type ImageHeader = ImageFormat & {
+    width: number;
+    height: number;
+};
+export declare function isHeic(bytes: Uint8Array): boolean;
+export declare function readImageHeader(bytes: Uint8Array): ImageHeader | undefined;

package/dist/server/imageHeader.js

@@ -0,0 +1,159 @@
+const SOF_MARKERS = new Set([
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf
+]);
+const ORIENTATION_TAG = 0x0112;
+const ROTATED_ORIENTATIONS = new Set([5, 6, 7, 8]);
+const HEIC_BRANDS = new Set([
+    'heic',
+    'heix',
+    'hevc',
+    'hevx',
+    'heim',
+    'heis',
+    'mif1',
+    'msf1'
+]);
+const AVIF_BRANDS = new Set(['avif', 'avis']);
+function ascii(bytes, start, length) {
+    return String.fromCharCode(...bytes.subarray(start, start + length));
+}
+function brandsOf(bytes) {
+    if (bytes.length < 16 || ascii(bytes, 4, 4) !== 'ftyp')
+        return [];
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const end = Math.min(bytes.length, view.getUint32(0));
+    const brands = [ascii(bytes, 8, 4)];
+    for (let offset = 16; offset + 4 <= end; offset += 4) {
+        brands.push(ascii(bytes, offset, 4));
+    }
+    return brands;
+}
+export function isHeic(bytes) {
+    const brands = brandsOf(bytes);
+    return (!brands.some((brand) => AVIF_BRANDS.has(brand)) &&
+        brands.some((brand) => HEIC_BRANDS.has(brand)));
+}
+function exifOrientation(view, start, end) {
+    if (end - start < 14)
+        return 1;
+    if (view.getUint32(start) !== 0x45786966 || view.getUint16(start + 4) !== 0)
+        return 1;
+    const tiff = start + 6;
+    const little = view.getUint16(tiff) === 0x4949;
+    const ifd = tiff + view.getUint32(tiff + 4, little);
+    if (ifd + 2 > end)
+        return 1;
+    const count = view.getUint16(ifd, little);
+    for (let index = 0; index < count; index += 1) {
+        const entry = ifd + 2 + index * 12;
+        if (entry + 12 > end)
+            return 1;
+        if (view.getUint16(entry, little) === ORIENTATION_TAG) {
+            return view.getUint16(entry + 8, little);
+        }
+    }
+    return 1;
+}
+function jpegSize(view) {
+    let orientation = 1;
+    let offset = 2;
+    while (offset + 4 <= view.byteLength) {
+        if (view.getUint8(offset) !== 0xff)
+            return undefined;
+        const marker = view.getUint8(offset + 1);
+        if (marker === 0xff) {
+            offset += 1;
+            continue;
+        }
+        const length = view.getUint16(offset + 2);
+        if (marker === 0xe1) {
+            orientation = exifOrientation(view, offset + 4, Math.min(view.byteLength, offset + 2 + length));
+        }
+        if (SOF_MARKERS.has(marker) && offset + 9 <= view.byteLength) {
+            const height = view.getUint16(offset + 5);
+            const width = view.getUint16(offset + 7);
+            return ROTATED_ORIENTATIONS.has(orientation)
+                ? { width: height, height: width }
+                : { width, height };
+        }
+        offset += 2 + length;
+    }
+    return undefined;
+}
+function webpSize(bytes, view) {
+    const chunk = ascii(bytes, 12, 4);
+    if (chunk === 'VP8X' && bytes.length >= 30) {
+        const width = 1 + (view.getUint32(24, true) & 0xffffff);
+        const height = 1 + (view.getUint32(27, true) & 0xffffff);
+        return { width, height };
+    }
+    if (chunk === 'VP8 ' && bytes.length >= 30) {
+        return {
+            width: view.getUint16(26, true) & 0x3fff,
+            height: view.getUint16(28, true) & 0x3fff
+        };
+    }
+    if (chunk === 'VP8L' && bytes.length >= 25) {
+        const bits = view.getUint32(21, true);
+        return { width: 1 + (bits & 0x3fff), height: 1 + ((bits >> 14) & 0x3fff) };
+    }
+    return undefined;
+}
+function avifSize(bytes, view) {
+    const limit = Math.min(bytes.length - 16, 65_536);
+    for (let offset = 4; offset < limit; offset += 1) {
+        if (ascii(bytes, offset, 4) === 'ispe') {
+            return {
+                width: view.getUint32(offset + 8),
+                height: view.getUint32(offset + 12)
+            };
+        }
+    }
+    return undefined;
+}
+function sizeOf(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (bytes.length >= 4 && view.getUint16(0) === 0xffd8) {
+        const size = jpegSize(view);
+        return size && { type: 'image/jpeg', extension: 'jpg', ...size };
+    }
+    if (bytes.length >= 24 && ascii(bytes, 1, 3) === 'PNG') {
+        return {
+            type: 'image/png',
+            extension: 'png',
+            width: view.getUint32(16),
+            height: view.getUint32(20)
+        };
+    }
+    if (bytes.length >= 10 && ascii(bytes, 0, 4) === 'GIF8') {
+        return {
+            type: 'image/gif',
+            extension: 'gif',
+            width: view.getUint16(6, true),
+            height: view.getUint16(8, true)
+        };
+    }
+    if (bytes.length >= 16 &&
+        ascii(bytes, 0, 4) === 'RIFF' &&
+        ascii(bytes, 8, 4) === 'WEBP') {
+        const size = webpSize(bytes, view);
+        return size && { type: 'image/webp', extension: 'webp', ...size };
+    }
+    if (brandsOf(bytes).some((brand) => AVIF_BRANDS.has(brand))) {
+        const size = avifSize(bytes, view);
+        return size && { type: 'image/avif', extension: 'avif', ...size };
+    }
+    return undefined;
+}
+export function readImageHeader(bytes) {
+    try {
+        const found = sizeOf(bytes);
+        if (found === undefined || found.width < 1 || found.height < 1) {
+            return undefined;
+        }
+        return found;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/server/index.d.ts

@@ -10,4 +10,9 @@ export { readTitle, seedTitleSql, settings, writeTitle } from './settings.ts';
 export { exchangeReply, exchangeRequest, sendCodeReply, sendCodeRequest, verifiedIdentity, verifyCodeReply, verifyCodeRequest } from './signInWire.ts';
 export type { VerifiedIdentity } from './signInWire.ts';
 export { findUser, users } from './users.ts';
-export type { D1Database } from '@cloudflare/workers-types';
+export { MEDIA_LIMIT_BYTES } from '../media.ts';
+export { localBusiness, product } from './jsonLd.ts';
+export type { JsonLd, LocalBusinessFacts, OpeningHours, PostalAddress, ProductFacts, Weekday } from './jsonLd.ts';
+export { definePages } from './pages.ts';
+export type { PageDefinition, PageHead, PageHero, PageParams, PageRequest, Pages } from './pages.ts';
+export type { D1Database, Fetcher, R2Bucket } from '@cloudflare/workers-types';

package/dist/server/index.js

@@ -7,3 +7,6 @@ export { deleteSession, sessions } from "./sessions.js";
 export { readTitle, seedTitleSql, settings, writeTitle } from "./settings.js";
 export { exchangeReply, exchangeRequest, sendCodeReply, sendCodeRequest, verifiedIdentity, verifyCodeReply, verifyCodeRequest } from "./signInWire.js";
 export { findUser, users } from "./users.js";
+export { MEDIA_LIMIT_BYTES } from "../media.js";
+export { localBusiness, product } from "./jsonLd.js";
+export { definePages } from "./pages.js";

package/dist/server/jsonLd.d.ts

@@ -0,0 +1,45 @@
+export type JsonLd = {
+    readonly '@context': 'https://schema.org';
+    readonly '@type': string;
+} & Readonly<Record<string, unknown>>;
+export type Weekday = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday';
+export type OpeningHours = {
+    days: Weekday | readonly Weekday[];
+    opens: string;
+    closes: string;
+};
+export type PostalAddress = {
+    street?: string;
+    locality?: string;
+    region?: string;
+    postalCode?: string;
+    country?: string;
+};
+export type LocalBusinessFacts = {
+    name: string;
+    url?: string;
+    type?: string;
+    image?: string | readonly string[];
+    description?: string;
+    telephone?: string;
+    email?: string;
+    address?: PostalAddress;
+    hours?: readonly OpeningHours[];
+    priceRange?: string;
+    sameAs?: readonly string[];
+};
+export type ProductFacts = {
+    name: string;
+    url?: string;
+    image?: string | readonly string[];
+    description?: string;
+    sku?: string;
+    brand?: string;
+    offer?: {
+        price: number;
+        currency: string;
+        availability?: 'InStock' | 'OutOfStock' | 'PreOrder' | 'BackOrder';
+    };
+};
+export declare function localBusiness(facts: LocalBusinessFacts): JsonLd;
+export declare function product(facts: ProductFacts): JsonLd;

package/dist/server/jsonLd.js

@@ -0,0 +1,88 @@
+const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+const CURRENCY = /^[A-Z]{3}$/;
+function present(fields) {
+    return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined &&
+        value !== '' &&
+        !(Array.isArray(value) && value.length === 0)));
+}
+function postalAddress(address) {
+    if (address === undefined)
+        return undefined;
+    return {
+        '@type': 'PostalAddress',
+        ...present({
+            streetAddress: address.street,
+            addressLocality: address.locality,
+            addressRegion: address.region,
+            postalCode: address.postalCode,
+            addressCountry: address.country
+        })
+    };
+}
+function openingHours(hours) {
+    return hours?.map(({ days, opens, closes }) => {
+        if (!TIME.test(opens) || !TIME.test(closes)) {
+            throw new Error(`Opening hours are 24-hour HH:MM times, like 09:00 and 17:30 (got ${opens} to ${closes})`);
+        }
+        return {
+            '@type': 'OpeningHoursSpecification',
+            dayOfWeek: typeof days === 'string' ? days : [...days],
+            opens,
+            closes
+        };
+    });
+}
+export function localBusiness(facts) {
+    return {
+        '@context': 'https://schema.org',
+        '@type': facts.type ?? 'LocalBusiness',
+        ...present({
+            name: facts.name,
+            url: facts.url,
+            image: facts.image,
+            description: facts.description,
+            telephone: facts.telephone,
+            email: facts.email,
+            address: postalAddress(facts.address),
+            openingHoursSpecification: openingHours(facts.hours),
+            priceRange: facts.priceRange,
+            sameAs: facts.sameAs
+        })
+    };
+}
+export function product(facts) {
+    const { offer } = facts;
+    if (offer !== undefined) {
+        if (!Number.isFinite(offer.price) || offer.price < 0) {
+            throw new Error(`A price is a number of at least 0 (got ${offer.price})`);
+        }
+        if (!CURRENCY.test(offer.currency)) {
+            throw new Error(`A currency is a three-letter ISO 4217 code, like CAD or USD (got ${offer.currency})`);
+        }
+    }
+    return {
+        '@context': 'https://schema.org',
+        '@type': 'Product',
+        ...present({
+            name: facts.name,
+            url: facts.url,
+            image: facts.image,
+            description: facts.description,
+            sku: facts.sku,
+            brand: facts.brand === undefined
+                ? undefined
+                : { '@type': 'Brand', name: facts.brand },
+            offers: offer === undefined
+                ? undefined
+                : present({
+                    '@type': 'Offer',
+                    price: offer.price.toFixed(2),
+                    priceCurrency: offer.currency,
+                    availability: offer.availability === undefined
+                        ? undefined
+                        : `https://schema.org/${offer.availability}`,
+                    url: facts.url
+                })
+        })
+    };
+}

package/dist/server/media.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from 'hono';
+import type { ServerEnv } from './env.ts';
+export declare function uploadMedia(c: Context<ServerEnv>): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 401, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 403, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 503, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 413, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 415, "json">) | (Response & import("hono").TypedResponse<{}, 201, "json">)>;
+export declare function serveMedia(c: Context<ServerEnv>): Promise<Response>;

package/dist/server/media.js

@@ -0,0 +1,135 @@
+import { drizzle } from 'drizzle-orm/d1';
+import { MEDIA_LIMIT_BYTES, media, mediaPath } from "../media.js";
+import { isHeic, readImageHeader } from "./imageHeader.js";
+import { sqlTable } from "./tables.js";
+const FORM_OVERHEAD_BYTES = 64 * 1024;
+const ALT_LIMIT = 500;
+const KEY = /^images\/[0-9a-f]{16}\.(?:jpg|png|webp|gif|avif)$/;
+const IMMUTABLE = 'public, max-age=31536000, immutable';
+const PLACEHOLDER = {
+    width: 24,
+    quality: 50,
+    format: 'jpeg',
+    fit: 'scale-down'
+};
+const PLACEHOLDER_LIMIT_BYTES = 4096;
+const NO_BUCKET = 'This app has no MEDIA bucket. Add "r2_buckets": [{ "binding": "MEDIA", "bucket_name": "media" }] to wrangler.jsonc; publishing creates the real one.';
+const NO_ALT = 'Describe this photo for someone who can’t see it: alt is required.';
+const TOO_LARGE = 'Photos can be up to 10 MB.';
+const HEIC = 'This is an iPhone HEIC photo, which browsers can’t show. Send it as a JPEG instead.';
+const UNKNOWN_TYPE = 'Photos must be JPEG, PNG, WebP, GIF or AVIF.';
+const target = sqlTable(media);
+function hex(bytes) {
+    return [...new Uint8Array(bytes)]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
+}
+function base64(bytes) {
+    let text = '';
+    const view = new Uint8Array(bytes);
+    for (let index = 0; index < view.length; index += 0x8000) {
+        text += String.fromCharCode(...view.subarray(index, index + 0x8000));
+    }
+    return btoa(text);
+}
+async function placeholderOf(c, key) {
+    if (import.meta.env.DEV)
+        return null;
+    const init = { method: 'GET', cf: { image: PLACEHOLDER } };
+    try {
+        const response = await fetch(new URL(mediaPath(key), c.req.url).href, init);
+        const type = response.headers.get('content-type') ?? '';
+        const length = Number(response.headers.get('content-length') ?? 0);
+        if (!response.ok ||
+            !type.startsWith('image/jpeg') ||
+            length > PLACEHOLDER_LIMIT_BYTES) {
+            await response.body?.cancel();
+            return null;
+        }
+        const bytes = await response.arrayBuffer();
+        return bytes.byteLength > PLACEHOLDER_LIMIT_BYTES
+            ? null
+            : `data:image/jpeg;base64,${base64(bytes)}`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function uploadMedia(c) {
+    const viewer = c.get('viewer');
+    if (viewer === null)
+        return c.json({ error: 'Signed out' }, 401);
+    if (!viewer.isAdmin)
+        return c.json({ error: 'forbidden' }, 403);
+    const bucket = c.env.MEDIA;
+    if (bucket === undefined)
+        return c.json({ error: NO_BUCKET }, 503);
+    const declared = Number(c.req.header('content-length') ?? 0);
+    if (declared > MEDIA_LIMIT_BYTES + FORM_OVERHEAD_BYTES) {
+        return c.json({ error: TOO_LARGE }, 413);
+    }
+    const form = await c.req.formData().catch(() => undefined);
+    const file = form?.get('file');
+    const alt = form?.get('alt');
+    if (!(file instanceof File)) {
+        return c.json({ error: 'Send the photo as the form field "file".' }, 400);
+    }
+    if (typeof alt !== 'string' || alt.trim() === '') {
+        return c.json({ error: NO_ALT }, 400);
+    }
+    if (alt.trim().length > ALT_LIMIT) {
+        return c.json({ error: `Keep alt to ${ALT_LIMIT} characters.` }, 400);
+    }
+    if (file.size > MEDIA_LIMIT_BYTES)
+        return c.json({ error: TOO_LARGE }, 413);
+    const buffer = await file.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    if (isHeic(bytes))
+        return c.json({ error: HEIC }, 415);
+    const header = readImageHeader(bytes);
+    if (header === undefined)
+        return c.json({ error: UNKNOWN_TYPE }, 415);
+    const digest = await crypto.subtle.digest('SHA-256', buffer);
+    const key = `images/${hex(digest).slice(0, 16)}.${header.extension}`;
+    await bucket.put(key, buffer, {
+        httpMetadata: { contentType: header.type, cacheControl: IMMUTABLE }
+    });
+    const row = await drizzle(c.env.DB)
+        .insert(target)
+        .values({
+        id: crypto.randomUUID(),
+        key,
+        width: header.width,
+        height: header.height,
+        placeholder: await placeholderOf(c, key),
+        alt: alt.trim(),
+        type: header.type,
+        bytes: bytes.byteLength
+    })
+        .returning()
+        .get();
+    return c.json(row, 201);
+}
+function unquoted(etag) {
+    return etag.replace(/^W\//, '').replaceAll('"', '').trim();
+}
+export async function serveMedia(c) {
+    const key = decodeURIComponent(c.req.path.slice('/media/'.length));
+    const bucket = c.env.MEDIA;
+    if (!KEY.test(key) || bucket === undefined) {
+        return c.text('No such photo', 404);
+    }
+    const seen = c.req.header('if-none-match');
+    const object = await bucket.get(key, seen === undefined ? {} : { onlyIf: { etagDoesNotMatch: unquoted(seen) } });
+    if (object === null)
+        return c.text('No such photo', 404);
+    const headers = new Headers({
+        'cache-control': IMMUTABLE,
+        'content-type': object.httpMetadata?.contentType ?? 'application/octet-stream',
+        etag: object.httpEtag,
+        'x-content-type-options': 'nosniff'
+    });
+    if (!('body' in object))
+        return new Response(null, { status: 304, headers });
+    return new Response(object.body, { headers });
+}

package/dist/server/pages.d.ts

@@ -0,0 +1,72 @@
+import type { Context } from 'hono';
+import type { MediaImage } from '../media.ts';
+import type { Row, Tables } from '../table.ts';
+import type { ServerEnv } from './env.ts';
+import type { JsonLd } from './jsonLd.ts';
+type ReadableName<Group extends Tables> = {
+    [Key in keyof Group & string]: Group[Key]['access']['read'] extends 'anyone' ? Key : never;
+}[keyof Group & string];
+type Answer<Value> = Value | Promise<Value>;
+export type PageParams = Readonly<Record<string, string>>;
+export type PageRequest<Group extends Tables> = {
+    url: URL;
+    params: PageParams;
+    rows: <Name extends ReadableName<Group>>(table: Name) => Promise<readonly Row<Group[Name]>[]>;
+    row: <Name extends ReadableName<Group>>(table: Name, id: string) => Promise<Row<Group[Name]> | undefined>;
+    photoUrl: (image: MediaImage) => string;
+};
+export type PageHero = {
+    image: MediaImage;
+    sizes: string;
+    aspect?: number;
+};
+export type PageHead<Group extends Tables> = {
+    title: string;
+    description?: string;
+    image?: MediaImage | null;
+    hero?: PageHero | null;
+    jsonLd?: JsonLd | readonly JsonLd[];
+    data?: {
+        [Name in ReadableName<Group>]?: readonly Row<Group[Name]>[];
+    };
+};
+type HeadOf<Group extends Tables> = (request: PageRequest<Group>) => Answer<PageHead<Group> | null>;
+export type PageDefinition<Group extends Tables> = HeadOf<Group> | {
+    head: HeadOf<Group>;
+    paths: (request: PageRequest<Group>) => Answer<readonly PageParams[]>;
+};
+type AnyHead = {
+    title: string;
+    description?: string;
+    image?: MediaImage | null;
+    hero?: PageHero | null;
+    jsonLd?: JsonLd | readonly JsonLd[];
+    data?: Readonly<Record<string, readonly unknown[] | undefined>>;
+};
+type AnyRequest = {
+    url: URL;
+    params: PageParams;
+    rows: (table: string) => Promise<readonly unknown[]>;
+    row: (table: string, id: string) => Promise<unknown>;
+    photoUrl: (image: MediaImage) => string;
+};
+type PageRoute = {
+    pattern: string;
+    segments: readonly string[];
+    head: (request: AnyRequest) => Answer<AnyHead | null>;
+    paths?: (request: AnyRequest) => Answer<readonly PageParams[]>;
+};
+export type Pages = {
+    readonly tables: Tables;
+    readonly routes: readonly PageRoute[];
+};
+export declare function definePages<Group extends Tables>(tables: Group, pages: Readonly<Record<string, PageDefinition<Group>>>): Pages;
+export declare function matchPage(pages: Pages, path: string): {
+    route: PageRoute;
+    params: PageParams;
+} | undefined;
+export declare function wantsHtml(c: Context<ServerEnv>): boolean;
+export declare function renderPage(c: Context<ServerEnv>, pages: Pages, route: PageRoute, params: PageParams): Promise<Response>;
+export declare function sitemap(c: Context<ServerEnv>, pages: Pages): Promise<Response>;
+export declare function robots(c: Context<ServerEnv>): Response;
+export {};