@johnhenry/sitefile 0.0.0-stage → 0.0.1

package/lib/src/server.js

@@ -0,0 +1,246 @@
+import http from 'node:http';
+import { SitefileError } from './errors.js';
+import { headersFor, matchRedirect, parseHeaderRules, parseRedirectRules } from './serve-rules.js';
+import { nfc } from './paths.js';
+import { mimeTypeFor } from './wbn.js';
+/** Reserved for the live-reload event stream while `serve --watch` runs. */
+export const RELOAD_PATH = '/__sitefile/reload';
+/** Added to served HTML (before the last `</body>`, else at the end) under `serve --watch`. */
+export const RELOAD_SCRIPT = `<script>new EventSource("${RELOAD_PATH}").onmessage=function(){location.reload()}</script>`;
+/** Open live-reload streams; {@link LiveReload.reload} tells every page to reload. */
+export class LiveReload {
+    clients = new Set();
+    /** Hold `res` open as a text/event-stream until the client goes away. */
+    attach(res, headers) {
+        res.writeHead(200, { ...headers, 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
+        res.write('retry: 1000\n\n');
+        this.clients.add(res);
+        res.on('close', () => this.clients.delete(res));
+    }
+    reload() {
+        for (const c of this.clients)
+            c.write('data: reload\n\n');
+    }
+    get size() {
+        return this.clients.size;
+    }
+}
+/** `html` with {@link RELOAD_SCRIPT} inserted before the last `</body` (ASCII case-insensitive), else appended. */
+export function injectReloadScript(html) {
+    const buf = Buffer.from(html.buffer, html.byteOffset, html.byteLength);
+    const at = buf.toString('latin1').toLowerCase().lastIndexOf('</body');
+    const script = Buffer.from(RELOAD_SCRIPT);
+    return at === -1 ? Buffer.concat([buf, script]) : Buffer.concat([buf.subarray(0, at), script, buf.subarray(at)]);
+}
+const NOT_FOUND_PAGE = '<!doctype html><meta charset="utf-8"><title>404 Not Found</title><h1>404 Not Found</h1>\n';
+const BAD_REQUEST_PAGE = '<!doctype html><meta charset="utf-8"><title>400 Bad Request</title><h1>400 Bad Request</h1>\n';
+const METHOD_PAGE = '<!doctype html><meta charset="utf-8"><title>405 Method Not Allowed</title><h1>405 Method Not Allowed</h1>\n';
+/** Decode a request path into safe segments, or undefined when it is malformed or unsafe. */
+export function safeSegments(rawPath) {
+    if (!rawPath.startsWith('/') || rawPath.includes('\\') || rawPath.includes('\0'))
+        return undefined;
+    const out = [];
+    for (const raw of rawPath.split('/')) {
+        if (raw === '')
+            continue;
+        let seg;
+        try {
+            seg = decodeURIComponent(raw);
+        }
+        catch {
+            return undefined;
+        }
+        // A decoded '/', '\\', NUL, control character, '.' or '..' could change what is read.
+        if (seg === '.' || seg === '..' || /[\\/\u0000-\u001f\u007f]/.test(seg))
+            return undefined;
+        // Tree paths are NFC; a request for an NFD spelling finds the same file.
+        out.push(nfc(seg));
+    }
+    return out;
+}
+function etagMatches(header, etag) {
+    if (header === undefined)
+        return false;
+    if (header.trim() === '*')
+        return true;
+    return header.split(',').some((t) => t.trim().replace(/^W\//, '') === etag);
+}
+function printable(s) {
+    return s.replace(/[^\x21-\x7e]/g, (c) => `%${c.charCodeAt(0).toString(16).padStart(2, '0')}`).slice(0, 512);
+}
+/**
+ * An HTTP server for an immutable Tree. GET and HEAD only; nothing outside the tree is
+ * ever reachable because lookups are exact map keys built from validated segments.
+ * Honours `/404.html`, `/_redirects` and `/_headers` (which it never serves), and answers
+ * `/about` with `/about.html` when there is no such file or directory.
+ */
+export function createSiteServer(site, options = {}) {
+    // A function is read per request (`serve --watch` swaps in each good rebuild).
+    const current = typeof site === 'function' ? site : () => site;
+    const base = { 'x-content-type-options': 'nosniff', 'cache-control': 'no-cache' };
+    if (options.serverId)
+        base['x-sitefile-server'] = options.serverId;
+    // `_redirects` / `_headers` are parsed once per tree (a watched server gets a new tree per rebuild).
+    let rulesTree;
+    let rules = { redirects: [], headers: [] };
+    const rulesFor = (t) => {
+        if (t !== rulesTree) {
+            const text = (p) => {
+                const f = t.get(p);
+                return f ? new TextDecoder().decode(f.bytes) : '';
+            };
+            rules = { redirects: parseRedirectRules(text('/_redirects')), headers: parseHeaderRules(text('/_headers')) };
+            rulesTree = t;
+        }
+        return rules;
+    };
+    const handler = (req, res) => {
+        const started = process.hrtime.bigint();
+        const method = req.method ?? 'GET';
+        const url = req.url ?? '/';
+        let bytes = 0;
+        const finish = (status, headers, body) => {
+            const buf = body === undefined ? undefined : typeof body === 'string' ? Buffer.from(body) : body;
+            res.writeHead(status, { ...base, ...headers });
+            if (buf !== undefined && method !== 'HEAD' && status !== 304) {
+                bytes = buf.byteLength;
+                res.end(buf);
+            }
+            else {
+                res.end();
+            }
+            const ms = Number((process.hrtime.bigint() - started) / 1000n) / 1000;
+            // `servers` probes carry the server's own id; they would only clutter the access log.
+            if (options.serverId !== undefined && req.headers['x-sitefile-probe'] === options.serverId)
+                return;
+            options.log?.(`${method} ${printable(url)} ${status} ${bytes} ${ms.toFixed(1)}ms`);
+        };
+        const page = (status, html, extra = {}) => finish(status, { 'content-type': 'text/html; charset=utf-8', 'content-length': Buffer.byteLength(html), ...extra }, html);
+        if (method !== 'GET' && method !== 'HEAD')
+            return page(405, METHOD_PAGE, { allow: 'GET, HEAD' });
+        const tree = current();
+        const { redirects, headers: headerRules } = rulesFor(tree);
+        const isFile = (p) => tree.isFile(p) && p !== '/_redirects' && p !== '/_headers';
+        const q = url.indexOf('?');
+        const hash = url.indexOf('#');
+        const end = Math.min(q === -1 ? url.length : q, hash === -1 ? url.length : hash);
+        const rawPath = url.slice(0, end);
+        if (options.liveReload && rawPath === RELOAD_PATH) {
+            if (method === 'HEAD')
+                return finish(200, { 'content-type': 'text/event-stream' }, undefined);
+            return options.liveReload.attach(res, base); // not access-logged: one long request per open page
+        }
+        const search = q === -1 ? '' : url.slice(q, hash === -1 || hash < q ? undefined : hash);
+        const segs = safeSegments(rawPath);
+        if (!segs)
+            return page(400, BAD_REQUEST_PAGE);
+        const trailingSlash = rawPath.endsWith('/');
+        const vpath = '/' + segs.join('/');
+        // `_headers` patterns match the request path (with its trailing slash).
+        const custom = headersFor(headerRules, vpath + (trailingSlash && segs.length > 0 ? '/' : ''));
+        const sendFile = (status, served) => {
+            const file = tree.get(served);
+            const type = mimeTypeFor(served);
+            const live = options.liveReload !== undefined && type.startsWith('text/html');
+            const body = live ? injectReloadScript(file.bytes) : file.bytes;
+            if (status !== 200)
+                return finish(status, { 'content-type': type, 'content-length': body.byteLength, ...custom }, body);
+            // An injected page is a different representation of the file: give it its own ETag.
+            const etag = `"${file.digest.replace(/^sha256:/, '')}${live ? '-live' : ''}"`;
+            if (etagMatches(req.headers['if-none-match'], etag))
+                return finish(304, { ...custom, etag }, undefined);
+            finish(200, { 'content-type': type, 'content-length': body.byteLength, ...custom, etag }, body);
+        };
+        /** The file for a path: exact, `<path>.html` (clean URLs), or `<dir>/index.html` with a trailing slash. */
+        const resolve = (p, slash) => {
+            if (isFile(p) && !(slash && p !== '/'))
+                return p;
+            if (!slash && p !== '/' && isFile(`${p}.html`))
+                return `${p}.html`;
+            if (slash && tree.isDirectory(p)) {
+                const index = p === '/' ? '/index.html' : `${p}/index.html`;
+                if (isFile(index))
+                    return index;
+            }
+            return undefined;
+        };
+        /** Apply the first matching `_redirects` rule (forced ones, or the others); false when none applies. */
+        const redirect = (forced) => {
+            for (const r of redirects) {
+                if (r.force !== forced)
+                    continue;
+                const rest = matchRedirect(r, vpath);
+                if (rest === undefined)
+                    continue;
+                const target = r.splat ? r.to.split(':splat').join(rest.split('/').map(encodeURIComponent).join('/')) : r.to;
+                if (r.status !== 200 && r.status !== 404) {
+                    finish(r.status, { location: target.includes('?') ? target : target + search, 'content-length': 0 }, undefined);
+                    return true;
+                }
+                // 200 (rewrite) and 404: serve the target path's file with that status.
+                const tq = target.indexOf('?');
+                const tpath = tq === -1 ? target : target.slice(0, tq);
+                const tsegs = safeSegments(tpath);
+                const served = tsegs ? resolve('/' + tsegs.join('/'), tpath.endsWith('/')) : undefined;
+                if (served === undefined)
+                    continue;
+                sendFile(r.status, served);
+                return true;
+            }
+            return false;
+        };
+        if (redirect(true))
+            return;
+        let served = resolve(vpath, trailingSlash);
+        if (served === undefined && !trailingSlash && tree.isDirectory(vpath)) {
+            const location = '/' + segs.map(encodeURIComponent).join('/') + '/' + search;
+            return finish(301, { location, 'content-length': 0 }, undefined);
+        }
+        if (served === undefined && redirect(false))
+            return;
+        if (served === undefined && options.spa && !/\.[^/.]+$/.test(segs[segs.length - 1] ?? '') && isFile('/index.html'))
+            served = '/index.html';
+        if (served !== undefined)
+            return sendFile(200, served);
+        if (isFile('/404.html'))
+            return sendFile(404, '/404.html');
+        page(404, NOT_FOUND_PAGE, custom);
+    };
+    const server = http.createServer(handler);
+    server.on('clientError', (_err, socket) => {
+        if (socket.writable)
+            socket.end('HTTP/1.1 400 Bad Request\r\nconnection: close\r\ncontent-length: 0\r\n\r\n');
+        else
+            socket.destroy();
+    });
+    return server;
+}
+/** Listen on host:port (port 0 = any free port); EADDRINUSE and friends become E_SERVER. */
+export function listen(server, host, port) {
+    return new Promise((resolve, reject) => {
+        const onError = (e) => {
+            const why = e.code === 'EADDRINUSE'
+                ? `port ${port} on ${host} is already in use`
+                : e.code === 'EACCES'
+                    ? `permission denied binding ${host}:${port}`
+                    : `cannot listen on ${host}:${port}: ${e.message}`;
+            reject(new SitefileError('E_SERVER', why, undefined, { cause: e }));
+        };
+        server.once('error', onError);
+        server.listen(port, host, () => {
+            server.off('error', onError);
+            resolve({ host, port: server.address().port });
+        });
+    });
+}
+export function closeServer(server) {
+    return new Promise((resolve) => {
+        server.close(() => resolve());
+        server.closeAllConnections();
+    });
+}
+export function formatUrl(host, port) {
+    const shown = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;
+    return `http://${shown.includes(':') ? `[${shown}]` : shown}:${port}/`;
+}
+//# sourceMappingURL=server.js.map

package/lib/src/servers.d.ts

@@ -0,0 +1,85 @@
+import { type ArchiveLimits } from './resources/types.js';
+import { Store } from './store.js';
+import { Tree } from './tree.js';
+/**
+ * Detached site servers ("containers"). One state file per server:
+ *
+ *   $SITEFILE_HOME/servers/<id>.json   state (this interface)
+ *   $SITEFILE_HOME/servers/<id>.log    stdout/stderr of the server process
+ *
+ * `serve -d` writes the state, spawns `node serve-worker.js <id>` detached, and the worker
+ * fills in `pid`, `host`, `port` and `ready` once it is listening. `servers` never trusts the
+ * file alone: a server is `running` only when its pid is alive AND the port answers with
+ * this server's `x-sitefile-server` header.
+ */
+export interface ServerState {
+    readonly id: string;
+    readonly name: string;
+    /** What the user asked to serve: the image reference as typed, or the directory. */
+    readonly image: string;
+    readonly source: {
+        readonly kind: 'image';
+        readonly imageId: string;
+    } | {
+        readonly kind: 'dir';
+        readonly path: string;
+    }
+    /** zip, tar, tar.gz/tgz, a Web Bundle or an OCI image archive; read again on every start, as a directory is. */
+     | {
+        readonly kind: 'archive';
+        readonly path: string;
+    };
+    readonly spa: boolean;
+    /** The requested bind address (port 0 = pick a free port). */
+    readonly bind: {
+        readonly host: string;
+        readonly port: number;
+    };
+    readonly host: string;
+    readonly port: number;
+    readonly pid: number;
+    readonly started: string;
+    readonly logFile: string;
+    readonly ready: boolean;
+    readonly error?: string;
+}
+export interface ServerView extends ServerState {
+    readonly status: 'running' | 'exited';
+    readonly url: string;
+}
+export declare class ServerRegistry {
+    readonly store: Store;
+    readonly dir: string;
+    private constructor();
+    static open(store?: Store): Promise<ServerRegistry>;
+    statePath(id: string): string;
+    logPath(id: string): string;
+    read(id: string): Promise<ServerState | undefined>;
+    write(state: ServerState): Promise<void>;
+    update(id: string, patch: Partial<ServerState>): Promise<ServerState | undefined>;
+    remove(id: string): Promise<void>;
+    all(): Promise<ServerState[]>;
+    /** Find by exact ID, exact name, or unique ID prefix. */
+    find(key: string): Promise<ServerState>;
+    /** Allocate an ID and validate/choose the name (names are unique among all servers, running or not). */
+    allocate(name: string | undefined): Promise<{
+        id: string;
+        name: string;
+    }>;
+    view(s: ServerState): Promise<ServerView>;
+}
+export declare function pidAlive(pid: number): boolean;
+/** Alive AND answering on its port with its own id header (guards against pid and port reuse). */
+export declare function isRunning(s: ServerState): Promise<boolean>;
+/** Load a directory into a Tree through the sandboxed local reader; hidden files (except .well-known) are not served. */
+export declare function loadDirectoryTree(dir: string): Promise<Tree>;
+/**
+ * Load an archive file into a Tree. The format comes from the bytes, never the name: zip, tar, tar.gz,
+ * a Web Bundle, or an OCI image archive (a tar holding an OCI layout, as `build -o x.oci.tar` and `save`
+ * write it). A zip, tar or Web Bundle is extracted with `limits` (unsafe entries are refused) and served
+ * like a directory, without hidden files except `.well-known`; an OCI archive serves its first image's
+ * files, like that image from the store, after checking every blob's digest and its site layer against `limits`.
+ */
+export declare function loadArchiveTree(file: string, limits?: ArchiveLimits): Promise<Tree>;
+/** The tree a server state serves. */
+export declare function loadServedTree(store: Store, source: ServerState['source']): Promise<Tree>;

package/lib/src/servers.js

@@ -0,0 +1,225 @@
+import { randomBytes } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { sha256 } from './digest.js';
+import { SitefileError } from './errors.js';
+import { blobPathOf, decodeIndex, extractImageFiles, MEDIA, parseConfig, parseManifest, siteLayerIndex } from './oci.js';
+import { extractArchive } from './resources/archive.js';
+import { LocalContext } from './resources/local.js';
+import { DEFAULT_ARCHIVE_LIMITS } from './resources/types.js';
+import { Store } from './store.js';
+import { Tree } from './tree.js';
+const NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/;
+export class ServerRegistry {
+    store;
+    dir;
+    constructor(store) {
+        this.store = store;
+        this.dir = path.join(store.home, 'servers');
+    }
+    static async open(store) {
+        const reg = new ServerRegistry(store ?? (await Store.open()));
+        await fs.mkdir(reg.dir, { recursive: true, mode: 0o700 });
+        return reg;
+    }
+    statePath(id) {
+        if (!/^[0-9a-f]{12}$/.test(id))
+            throw new SitefileError('E_SERVER', `invalid server id '${id}'`);
+        return path.join(this.dir, `${id}.json`);
+    }
+    logPath(id) {
+        return path.join(this.dir, `${id}.log`);
+    }
+    async read(id) {
+        try {
+            return JSON.parse(await fs.readFile(this.statePath(id), 'utf8'));
+        }
+        catch (e) {
+            if (e.code === 'ENOENT' || e instanceof SyntaxError)
+                return undefined;
+            throw e;
+        }
+    }
+    async write(state) {
+        const dest = this.statePath(state.id);
+        const tmp = `${dest}.${randomBytes(4).toString('hex')}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
+        await fs.rename(tmp, dest);
+    }
+    async update(id, patch) {
+        const cur = await this.read(id);
+        if (!cur)
+            return undefined;
+        const next = { ...cur, ...patch };
+        await this.write(next);
+        return next;
+    }
+    async remove(id) {
+        await fs.rm(this.statePath(id), { force: true });
+        await fs.rm(this.logPath(id), { force: true });
+    }
+    async all() {
+        const out = [];
+        for (const f of await fs.readdir(this.dir)) {
+            const m = /^([0-9a-f]{12})\.json$/.exec(f);
+            const s = m ? await this.read(m[1]) : undefined;
+            if (s)
+                out.push(s);
+        }
+        return out.sort((a, b) => (a.started < b.started ? -1 : a.started > b.started ? 1 : 0));
+    }
+    /** Find by exact ID, exact name, or unique ID prefix. */
+    async find(key) {
+        const all = await this.all();
+        const hit = all.find((s) => s.id === key) ?? all.find((s) => s.name === key);
+        if (hit)
+            return hit;
+        const pre = key.length >= 3 ? all.filter((s) => s.id.startsWith(key)) : [];
+        if (pre.length === 1)
+            return pre[0];
+        if (pre.length > 1)
+            throw new SitefileError('E_SERVER', `ambiguous server '${key}' matches ${pre.length} servers`);
+        throw new SitefileError('E_NOT_FOUND', `no such server: ${key}`);
+    }
+    /** Allocate an ID and validate/choose the name (names are unique among all servers, running or not). */
+    async allocate(name) {
+        const all = await this.all();
+        if (name !== undefined) {
+            if (!NAME_RE.test(name))
+                throw new SitefileError('E_USAGE', `invalid server name '${name}' (letters, digits, '_', '.', '-')`);
+            if (all.some((s) => s.name === name))
+                throw new SitefileError('E_SERVER', `a server named '${name}' already exists; remove it with "sitefile rm ${name}"`);
+        }
+        const id = randomBytes(6).toString('hex');
+        return { id, name: name ?? `site-${id.slice(0, 6)}` };
+    }
+    async view(s) {
+        const running = await isRunning(s);
+        return { ...s, status: running ? 'running' : 'exited', url: s.ready ? urlOf(s) : '' };
+    }
+}
+function urlOf(s) {
+    const shown = s.host === '0.0.0.0' ? '127.0.0.1' : s.host === '::' ? '::1' : s.host;
+    return `http://${shown.includes(':') ? `[${shown}]` : shown}:${s.port}/`;
+}
+export function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+/** Alive AND answering on its port with its own id header (guards against pid and port reuse). */
+export async function isRunning(s) {
+    if (!s.ready || !pidAlive(s.pid))
+        return false;
+    const host = s.host === '0.0.0.0' ? '127.0.0.1' : s.host === '::' ? '::1' : s.host;
+    return new Promise((resolve) => {
+        const req = http.request({ host, port: s.port, method: 'HEAD', path: '/', headers: { 'x-sitefile-probe': s.id }, timeout: 1500, agent: false }, (res) => {
+            res.resume();
+            resolve(res.headers['x-sitefile-server'] === s.id);
+        });
+        req.on('timeout', () => req.destroy());
+        req.on('error', () => resolve(false));
+        req.end();
+    });
+}
+/** Paths of `tree` a directory or archive serves: no hidden files except `.well-known`. */
+function visible(tree) {
+    return Tree.fromFiles(tree.entries().filter(([p]) => p.split('/').every((seg) => !seg.startsWith('.') || seg === '' || seg === '.well-known')));
+}
+/** Load a directory into a Tree through the sandboxed local reader; hidden files (except .well-known) are not served. */
+export async function loadDirectoryTree(dir) {
+    const ctx = await LocalContext.open(dir, { sitefileignore: false });
+    const { tree } = await ctx.readTree('', 'serve');
+    return visible(tree);
+}
+/**
+ * Load an archive file into a Tree. The format comes from the bytes, never the name: zip, tar, tar.gz,
+ * a Web Bundle, or an OCI image archive (a tar holding an OCI layout, as `build -o x.oci.tar` and `save`
+ * write it). A zip, tar or Web Bundle is extracted with `limits` (unsafe entries are refused) and served
+ * like a directory, without hidden files except `.well-known`; an OCI archive serves its first image's
+ * files, like that image from the store, after checking every blob's digest and its site layer against `limits`.
+ */
+export async function loadArchiveTree(file, limits = DEFAULT_ARCHIVE_LIMITS) {
+    const origin = file;
+    const unreadable = () => new SitefileError('E_ARCHIVE', `cannot read '${origin}'`);
+    const st = await fs.stat(file).catch((e) => {
+        throw e.code === 'ENOENT' ? new SitefileError('E_NOT_FOUND', `'${origin}' does not exist`) : unreadable();
+    });
+    if (!st.isFile())
+        throw new SitefileError('E_TYPE', `'${origin}' is not a file`);
+    // The archive is at most its expanded size plus tar framing for every entry.
+    if (st.size > limits.maxTotalBytes + (limits.maxEntries + 2) * 4 * 512) {
+        throw new SitefileError('E_ARCHIVE_LIMIT', `${origin}: archive expands beyond ${limits.maxTotalBytes} bytes`);
+    }
+    const bytes = new Uint8Array(await fs.readFile(file).catch(() => { throw unreadable(); }));
+    const tree = await extractArchive(bytes, origin, limits);
+    return tree.get('/oci-layout') ? ociArchiveTree(tree, origin, limits) : visible(tree);
+}
+/** The files of the first image in an extracted OCI layout. */
+async function ociArchiveTree(layout, origin, limits) {
+    const bad = (why) => new SitefileError('E_ARCHIVE', `${origin}: ${why}`);
+    const blob = (digest, size) => {
+        const node = layout.get(blobPathOf(digest));
+        if (!node)
+            throw bad(`OCI archive has no blob ${digest}`);
+        if (sha256(node.bytes) !== digest || node.bytes.byteLength !== size)
+            throw bad(`blob ${digest} does not match its digest`);
+        return node.bytes;
+    };
+    const index = layout.get('/index.json');
+    if (!index)
+        throw bad('OCI archive has no index.json');
+    let entries;
+    try {
+        entries = decodeIndex(index.bytes);
+    }
+    catch {
+        throw bad('OCI archive index.json is corrupt');
+    }
+    const first = entries[0];
+    if (!first)
+        throw bad('OCI archive holds no image');
+    const manifestBytes = blob(first.digest, first.size);
+    let m;
+    try {
+        m = parseManifest(manifestBytes);
+    }
+    catch {
+        throw bad("OCI archive's first manifest is not an image manifest");
+    }
+    const configBytes = blob(m.config.digest, m.config.size);
+    let cfg;
+    try {
+        cfg = parseConfig(configBytes);
+    }
+    catch {
+        throw bad("OCI archive's image config is corrupt");
+    }
+    const layer = m.layers[siteLayerIndex(m, cfg)];
+    let layerBytes = new Uint8Array(0); // extractImageFiles reports "not a Sitefile image"
+    if (layer && (layer.mediaType === MEDIA.layer || layer.mediaType === MEDIA.layerTar)) {
+        layerBytes = blob(layer.digest, layer.size);
+        // Hold the site layer to the archive limits before it is fully decoded.
+        await extractArchive(layerBytes, origin, limits);
+    }
+    return extractImageFiles(m, cfg, layerBytes, origin);
+}
+/** The tree a server state serves. */
+export async function loadServedTree(store, source) {
+    switch (source.kind) {
+        case 'image':
+            return store.loadTree(source.imageId);
+        case 'dir':
+            return loadDirectoryTree(source.path);
+        case 'archive':
+            return loadArchiveTree(source.path);
+    }
+}
+//# sourceMappingURL=servers.js.map

package/lib/src/site.d.ts

@@ -0,0 +1,60 @@
+import { type SourceSpan } from './errors.js';
+import type { RedirectStatus } from './language/ast.js';
+import type { Tree } from './tree.js';
+/**
+ * Check a SITEMAP/FEED `BASE`: an absolute http(s) URL with a host and no credentials,
+ * query, fragment, whitespace or control characters. Returns it without trailing slashes.
+ */
+export declare function checkBaseUrl(raw: string, what: string, span: SourceSpan): string;
+/** `<base><path>` with each segment percent-encoded; `…/index.html` becomes its directory URL `…/`. */
+export declare function pageUrl(base: string, path: string): string;
+/** Escape text for XML content and attribute values; characters XML 1.0 forbids become U+FFFD. */
+export declare function xmlEscape(s: string): string;
+/** sitemaps.org XML for every `.html` file in the tree except `/404.html`, sorted by path. */
+export declare function sitemapXml(tree: Tree, base: string): string;
+export interface FeedDate {
+    /** RFC 3339 form written to the feed. */
+    readonly text: string;
+    /** Seconds since the epoch (UTC), for picking the newest entry. */
+    readonly seconds: number;
+    /** Fractional seconds as 9 digits. */
+    readonly fraction: string;
+}
+/** `YYYY-MM-DD` (midnight UTC) or an RFC 3339 date-time; undefined when it is neither. */
+export declare function parseFeedDate(s: string): FeedDate | undefined;
+export interface FeedEntry {
+    readonly title: string;
+    readonly url: string;
+    readonly date: FeedDate;
+    readonly author?: string;
+    readonly summary?: string;
+    readonly content?: string;
+}
+/** Atom 1.0. The feed's id is its own URL; each entry's id is its link. */
+export declare function atomXml(feed: {
+    title: string;
+    siteUrl: string;
+    selfUrl: string;
+    entries: readonly FeedEntry[];
+}): string;
+export interface RedirectRule {
+    readonly from: string;
+    readonly to: string;
+    readonly status: RedirectStatus;
+}
+export interface HeaderRule {
+    readonly pattern: string;
+    readonly name: string;
+    readonly value: string;
+}
+/** Check a REDIRECT source (`from`) or HEADER pattern: an absolute path with no spaces or control characters. */
+export declare function checkSitePath(raw: string, what: string, span: SourceSpan): string;
+/** Check a REDIRECT target: an absolute path or an http(s) URL. */
+export declare function checkRedirectTarget(raw: string, span: SourceSpan): string;
+export declare function checkHeaderName(raw: string, span: SourceSpan): string;
+/** The header value: trimmed of spaces and tabs; non-empty, no control characters other than tab. */
+export declare function checkHeaderValue(raw: string, name: string, span: SourceSpan): string;
+/** `/_redirects` in the Netlify / Cloudflare Pages format: `from to status`, one per line, in source order. */
+export declare function redirectsFile(rules: readonly RedirectRule[]): string;
+/** `/_headers`: one block per path pattern (in order of first use), its headers indented in source order. */
+export declare function headersFile(rules: readonly HeaderRule[]): string;