@johnhenry/sitefile 0.0.0 → 0.0.2

package/lib/src/resources/network.d.ts

@@ -0,0 +1,70 @@
+import { type SourceSpan } from '../errors.js';
+/**
+ * Explicit network settings for everything sitefile fetches (IMPORT over http(s), Git, registries).
+ * Nothing here is read from the environment implicitly: `HTTP(S)_PROXY` stays ignored, and the CLI
+ * reads `SITEFILE_PROXY` and friends through {@link networkFromEnv}. Embedders pass this in code
+ * (`FetchPolicy.network`, `RegistryOptions.network`).
+ */
+export interface NetworkSettings {
+    /** `http://[user:password@]host[:port]`: a CONNECT tunnel for https targets, absolute-form requests for http. */
+    readonly proxy?: string | undefined;
+    /** Hosts reached directly, never through the proxy (`NO_PROXY` syntax, see {@link hostMatches}). */
+    readonly noProxy?: readonly string[] | undefined;
+    /** When non-empty, only hosts matching one of these patterns may be contacted. */
+    readonly allowHosts?: readonly string[] | undefined;
+    /** Hosts never contacted; a deny rule beats an allow rule. */
+    readonly denyHosts?: readonly string[] | undefined;
+    /** Time limit for establishing the TCP connection (to the target, or to the proxy), ms. */
+    readonly connectTimeoutMs?: number | undefined;
+    /** Longest wait for data once connected (idle time), ms. */
+    readonly readTimeoutMs?: number | undefined;
+}
+/** A configured HTTP proxy, parsed. */
+export interface ProxyConfig {
+    readonly host: string;
+    readonly port: number;
+    /** `Basic …` when the URL carries credentials. */
+    readonly authorization?: string | undefined;
+    /** The proxy URL without credentials, for messages. */
+    readonly shown: string;
+}
+/** Split a list given as one string (commas and/or whitespace). */
+export declare function splitList(raw: string | undefined): string[];
+/** Parse a proxy URL, or throw E_USAGE. Credentials never appear in the message. */
+export declare function parseProxy(raw: string): ProxyConfig;
+/**
+ * True when `host` (as in a URL, IPv6 without brackets) on `port` matches `pattern`:
+ *   `*`                      every host
+ *   `example.com`            example.com and every subdomain (`.example.com` and `*.example.com` too)
+ *   `10.0.0.0/8`, `fd00::/8` IP-literal hosts in that network; `192.0.2.1`, `::1` that address
+ *   any of these + `:port`   only that port (`[::1]:8080` for IPv6)
+ * Patterns match the host as written in the URL: a name pattern never matches an IP literal and an
+ * IP pattern never matches a name, whatever it resolves to (the private-address rule covers that).
+ */
+export declare function hostMatches(host: string, port: number, pattern: string): boolean;
+/** Default port of an http(s) URL. */
+export declare function urlPort(url: URL): number;
+/**
+ * Apply the allow/deny host rules to one hop (every redirect, token realm and blob CDN hop included).
+ * Throws E_HOST_BLOCKED naming the rule; a deny rule beats an allow rule.
+ */
+export declare function checkHostRules(url: URL, network: NetworkSettings | undefined, shown: string, span?: SourceSpan): void;
+/** The proxy to use for `url`, or undefined for a direct connection (no proxy, or a no-proxy match). */
+export declare function proxyFor(url: URL, network: NetworkSettings | undefined): ProxyConfig | undefined;
+/** A usage problem in `network` (bad proxy URL, host pattern or timeout), or undefined. */
+export declare function networkProblem(network: NetworkSettings): string | undefined;
+/** Parse `SITEFILE_FETCH_TIMEOUT`: `<ms>` (connect and read) or `connect=<ms>,read=<ms>` (either part optional). */
+export declare function parseFetchTimeout(raw: string): {
+    connectTimeoutMs?: number;
+    readTimeoutMs?: number;
+};
+/**
+ * Network settings from `SITEFILE_PROXY`, `SITEFILE_NO_PROXY`, `SITEFILE_ALLOW_HOSTS`,
+ * `SITEFILE_DENY_HOSTS` (comma- or space-separated) and `SITEFILE_FETCH_TIMEOUT`. Empty values are unset.
+ * `HTTP_PROXY`, `HTTPS_PROXY` and `NO_PROXY` are never read.
+ */
+export declare function networkFromEnv(env?: NodeJS.ProcessEnv): NetworkSettings;
+/** `over` on top of `base`: the proxy and timeouts are replaced, the host lists are joined (duplicates dropped). */
+export declare function mergeNetwork(base: NetworkSettings, over: NetworkSettings): NetworkSettings;
+/** True when any setting is present. */
+export declare function hasNetworkSettings(n: NetworkSettings | undefined): boolean;

package/lib/src/resources/network.js

@@ -0,0 +1,304 @@
+import { isIP } from 'node:net';
+import { SitefileError } from '../errors.js';
+/** Split a list given as one string (commas and/or whitespace). */
+export function splitList(raw) {
+    return (raw ?? '')
+        .split(/[\s,]+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+/** A proxy URL with any credentials removed. */
+function shownProxy(raw) {
+    try {
+        const u = new URL(raw);
+        u.username = '';
+        u.password = '';
+        return u.href.replace(/\/$/, '');
+    }
+    catch {
+        return '<invalid url>';
+    }
+}
+/** Percent-decode, keeping invalid escapes as written (bytes decoded as UTF-8, lossily). */
+function percentDecode(s) {
+    const bytes = [];
+    for (let i = 0; i < s.length;) {
+        if (s[i] === '%' && /^[0-9a-fA-F]{2}$/.test(s.slice(i + 1, i + 3))) {
+            bytes.push(parseInt(s.slice(i + 1, i + 3), 16));
+            i += 3;
+        }
+        else {
+            const c = Buffer.from(s[i], 'utf8');
+            bytes.push(...c);
+            i += 1;
+        }
+    }
+    return Buffer.from(bytes).toString('utf8');
+}
+/** Parse a proxy URL, or throw E_USAGE. Credentials never appear in the message. */
+export function parseProxy(raw) {
+    const bad = () => new SitefileError('E_USAGE', `invalid proxy URL '${shownProxy(raw)}': expected http://[user:password@]host[:port]`);
+    let u;
+    try {
+        u = new URL(raw);
+    }
+    catch {
+        throw bad();
+    }
+    if (u.protocol !== 'http:' || u.hostname === '' || (u.pathname !== '/' && u.pathname !== '') || u.search !== '' || u.hash !== '')
+        throw bad();
+    const host = u.hostname.replace(/^\[|\]$/g, '');
+    const port = u.port === '' ? 80 : Number(u.port);
+    const user = percentDecode(u.username);
+    const pass = percentDecode(u.password);
+    const authorization = user !== '' || pass !== '' ? `Basic ${Buffer.from(`${user}:${pass}`).toString('base64')}` : undefined;
+    return { host, port, authorization, shown: shownProxy(raw) };
+}
+function ipToBig(ip) {
+    const family = isIP(ip);
+    if (family === 4) {
+        const addr = ip.split('.').reduce((acc, b) => (acc << 8n) | BigInt(Number(b)), 0n);
+        return { family: 4, addr };
+    }
+    if (family === 6) {
+        let s = ip.toLowerCase();
+        const v4 = /(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(s);
+        if (v4) {
+            const [b0, b1, b2, b3] = v4.slice(1).map(Number);
+            s = s.slice(0, v4.index) + ((b0 << 8) | b1).toString(16) + ':' + ((b2 << 8) | b3).toString(16);
+        }
+        const [head, tail] = s.split('::');
+        const h = head ? head.split(':') : [];
+        const t = tail ? tail.split(':') : [];
+        const groups = [...h, ...(tail === undefined ? [] : new Array(8 - h.length - t.length).fill('0')), ...t];
+        if (groups.length !== 8)
+            return undefined;
+        return { family: 6, addr: groups.reduce((acc, g) => (acc << 16n) | BigInt(parseInt(g, 16)), 0n) };
+    }
+    return undefined;
+}
+const HOSTNAME_RE = /^[a-z0-9_-]+(?:\.[a-z0-9_-]+)*$/;
+/** Parse one pattern; undefined when it is not valid. */
+function parsePattern(raw) {
+    let p = raw.trim().toLowerCase();
+    if (p === '')
+        return undefined;
+    if (p === '*')
+        return { any: true };
+    let port;
+    // [v6]:port, [v6], v4:port, name:port. A bare IPv6 (two or more colons) has no port.
+    const bracket = /^\[([^\]]+)\](?::(\d+))?$/.exec(p);
+    if (bracket) {
+        p = bracket[1];
+        if (bracket[2] !== undefined)
+            port = Number(bracket[2]);
+    }
+    else if ((p.match(/:/g) ?? []).length === 1) {
+        const i = p.indexOf(':');
+        const ps = p.slice(i + 1);
+        if (!/^\d+$/.test(ps))
+            return undefined;
+        port = Number(ps);
+        p = p.slice(0, i);
+    }
+    if (port !== undefined && (port < 1 || port > 65535))
+        return undefined;
+    const withPort = (x) => (port === undefined ? x : { ...x, port });
+    const slash = p.indexOf('/');
+    if (slash !== -1) {
+        const ip = ipToBig(p.slice(0, slash));
+        const ps = p.slice(slash + 1);
+        if (!ip || !/^\d+$/.test(ps))
+            return undefined;
+        const prefix = Number(ps);
+        if (prefix > (ip.family === 4 ? 32 : 128))
+            return undefined;
+        return withPort({ net: { ...ip, prefix } });
+    }
+    const ip = ipToBig(p);
+    if (ip)
+        return withPort({ net: { ...ip, prefix: ip.family === 4 ? 32 : 128 } });
+    if (p.startsWith('*.'))
+        p = p.slice(2);
+    else if (p.startsWith('.'))
+        p = p.slice(1);
+    if (p.endsWith('.'))
+        p = p.slice(0, -1);
+    if (!HOSTNAME_RE.test(p))
+        return undefined;
+    return withPort({ domain: p });
+}
+/**
+ * True when `host` (as in a URL, IPv6 without brackets) on `port` matches `pattern`:
+ *   `*`                      every host
+ *   `example.com`            example.com and every subdomain (`.example.com` and `*.example.com` too)
+ *   `10.0.0.0/8`, `fd00::/8` IP-literal hosts in that network; `192.0.2.1`, `::1` that address
+ *   any of these + `:port`   only that port (`[::1]:8080` for IPv6)
+ * Patterns match the host as written in the URL: a name pattern never matches an IP literal and an
+ * IP pattern never matches a name, whatever it resolves to (the private-address rule covers that).
+ */
+export function hostMatches(host, port, pattern) {
+    const p = parsePattern(pattern);
+    return p !== undefined && matches(normalizeHost(host), port, p);
+}
+function normalizeHost(host) {
+    let h = host.toLowerCase();
+    if (h.startsWith('[') && h.endsWith(']'))
+        h = h.slice(1, -1);
+    if (h.endsWith('.'))
+        h = h.slice(0, -1);
+    return h;
+}
+function matches(host, port, p) {
+    if (p.any)
+        return true;
+    if (p.port !== undefined && p.port !== port)
+        return false;
+    if (p.domain !== undefined)
+        return host === p.domain || host.endsWith(`.${p.domain}`);
+    if (p.net) {
+        const ip = ipToBig(host);
+        if (!ip || ip.family !== p.net.family)
+            return false;
+        const bits = BigInt(ip.family === 4 ? 32 : 128);
+        const shift = bits - BigInt(p.net.prefix);
+        return ip.addr >> shift === p.net.addr >> shift;
+    }
+    return false;
+}
+/** The first pattern of `list` that matches, if any. */
+function firstMatch(host, port, list) {
+    const h = normalizeHost(host);
+    for (const raw of list ?? []) {
+        const p = parsePattern(raw);
+        if (p && matches(h, port, p))
+            return raw.trim();
+    }
+    return undefined;
+}
+/** Default port of an http(s) URL. */
+export function urlPort(url) {
+    return url.port !== '' ? Number(url.port) : url.protocol === 'http:' ? 80 : 443;
+}
+/**
+ * Apply the allow/deny host rules to one hop (every redirect, token realm and blob CDN hop included).
+ * Throws E_HOST_BLOCKED naming the rule; a deny rule beats an allow rule.
+ */
+export function checkHostRules(url, network, shown, span) {
+    if (!network)
+        return;
+    const host = normalizeHost(url.hostname);
+    const port = urlPort(url);
+    const denied = firstMatch(host, port, network.denyHosts);
+    if (denied !== undefined) {
+        throw new SitefileError('E_HOST_BLOCKED', `refusing to connect to ${host}: it matches deny-hosts rule '${denied}' (${shown})`, span);
+    }
+    if ((network.allowHosts ?? []).length > 0 && firstMatch(host, port, network.allowHosts) === undefined) {
+        throw new SitefileError('E_HOST_BLOCKED', `refusing to connect to ${host}: it matches no allow-hosts rule (${shown})`, span);
+    }
+}
+/** The proxy to use for `url`, or undefined for a direct connection (no proxy, or a no-proxy match). */
+export function proxyFor(url, network) {
+    if (!network?.proxy)
+        return undefined;
+    if (firstMatch(url.hostname, urlPort(url), network.noProxy) !== undefined)
+        return undefined;
+    return parseProxy(network.proxy);
+}
+// ------------------------------------------------------------------ configuration
+/** A usage problem in `network` (bad proxy URL, host pattern or timeout), or undefined. */
+export function networkProblem(network) {
+    if (network.proxy) {
+        try {
+            parseProxy(network.proxy);
+        }
+        catch (e) {
+            return e.message;
+        }
+    }
+    for (const [name, list] of [
+        ['no-proxy', network.noProxy],
+        ['allow-hosts', network.allowHosts],
+        ['deny-hosts', network.denyHosts],
+    ]) {
+        for (const p of list ?? []) {
+            if (!parsePattern(p))
+                return `invalid ${name} pattern '${p}': expected *, a host name (example.com, .example.com, *.example.com), an IP address or a CIDR network, optionally with :port`;
+        }
+    }
+    for (const [name, v] of [
+        ['connect timeout', network.connectTimeoutMs],
+        ['read timeout', network.readTimeoutMs],
+    ]) {
+        if (v !== undefined && (!Number.isSafeInteger(v) || v <= 0))
+            return `the ${name} must be a positive integer (ms)`;
+    }
+    return undefined;
+}
+function positiveMs(raw, what) {
+    if (!/^\d+$/.test(raw) || Number(raw) <= 0 || !Number.isSafeInteger(Number(raw))) {
+        throw new SitefileError('E_USAGE', `${what} expects a positive integer (ms), got '${raw}'`);
+    }
+    return Number(raw);
+}
+/** Parse `SITEFILE_FETCH_TIMEOUT`: `<ms>` (connect and read) or `connect=<ms>,read=<ms>` (either part optional). */
+export function parseFetchTimeout(raw) {
+    const s = raw.trim();
+    if (s === '')
+        return {};
+    if (/^\d+$/.test(s)) {
+        const ms = positiveMs(s, 'SITEFILE_FETCH_TIMEOUT');
+        return { connectTimeoutMs: ms, readTimeoutMs: ms };
+    }
+    const out = {};
+    for (const part of s.split(',')) {
+        const m = /^\s*(connect|read)\s*=\s*(\S*)\s*$/.exec(part);
+        if (!m)
+            throw new SitefileError('E_USAGE', `SITEFILE_FETCH_TIMEOUT expects <ms> or connect=<ms>,read=<ms>, got '${raw}'`);
+        const ms = positiveMs(m[2], `SITEFILE_FETCH_TIMEOUT ${m[1]}`);
+        if (m[1] === 'connect')
+            out.connectTimeoutMs = ms;
+        else
+            out.readTimeoutMs = ms;
+    }
+    return out;
+}
+/**
+ * Network settings from `SITEFILE_PROXY`, `SITEFILE_NO_PROXY`, `SITEFILE_ALLOW_HOSTS`,
+ * `SITEFILE_DENY_HOSTS` (comma- or space-separated) and `SITEFILE_FETCH_TIMEOUT`. Empty values are unset.
+ * `HTTP_PROXY`, `HTTPS_PROXY` and `NO_PROXY` are never read.
+ */
+export function networkFromEnv(env = process.env) {
+    const proxy = (env.SITEFILE_PROXY ?? '').trim();
+    return {
+        ...(proxy !== '' ? { proxy } : {}),
+        ...(splitList(env.SITEFILE_NO_PROXY).length ? { noProxy: splitList(env.SITEFILE_NO_PROXY) } : {}),
+        ...(splitList(env.SITEFILE_ALLOW_HOSTS).length ? { allowHosts: splitList(env.SITEFILE_ALLOW_HOSTS) } : {}),
+        ...(splitList(env.SITEFILE_DENY_HOSTS).length ? { denyHosts: splitList(env.SITEFILE_DENY_HOSTS) } : {}),
+        ...parseFetchTimeout(env.SITEFILE_FETCH_TIMEOUT ?? ''),
+    };
+}
+/** `over` on top of `base`: the proxy and timeouts are replaced, the host lists are joined (duplicates dropped). */
+export function mergeNetwork(base, over) {
+    const join = (a, b) => {
+        const all = [...new Set([...(a ?? []), ...(b ?? [])])];
+        return all.length ? all : undefined;
+    };
+    const out = {
+        proxy: over.proxy ?? base.proxy,
+        noProxy: join(base.noProxy, over.noProxy),
+        allowHosts: join(base.allowHosts, over.allowHosts),
+        denyHosts: join(base.denyHosts, over.denyHosts),
+        connectTimeoutMs: over.connectTimeoutMs ?? base.connectTimeoutMs,
+        readTimeoutMs: over.readTimeoutMs ?? base.readTimeoutMs,
+    };
+    for (const k of Object.keys(out))
+        if (out[k] === undefined)
+            delete out[k];
+    return out;
+}
+/** True when any setting is present. */
+export function hasNetworkSettings(n) {
+    return !!n && Object.values(n).some((v) => v !== undefined && !(Array.isArray(v) && v.length === 0));
+}
+//# sourceMappingURL=network.js.map

package/lib/src/resources/types.d.ts

@@ -1,3 +1,4 @@
+import type { NetworkSettings } from './network.js';
 import type { Tree } from '../tree.js';
 export interface Provenance {
     /** The URI as written (after variable interpolation), or `./relative/path`. */
@@ -49,6 +50,11 @@ export interface FetchPolicy {
      * private CAs; certificate and hostname verification stay on.
      */
     readonly ca?: string | Buffer | undefined;
+    /**
+     * Proxy, host rules and connect/read timeouts (see {@link NetworkSettings}). Unset: direct
+     * connections, every public host, only the total `timeoutMs`.
+     */
+    readonly network?: NetworkSettings | undefined;
 }
 export declare const DEFAULT_FETCH_POLICY: FetchPolicy;
 /** Limits applied when an archive is extracted with `IMPORT … AS tree`. Defaults are secure. */

package/lib/src/secrets.js

@@ -84,7 +84,7 @@ export function redactError(e, secrets) {
     if (!isSitefileError(e) || !secrets || secrets.size === 0)
         return e;
     const detail = redactSecrets(e.detail, secrets);
-    return detail === e.detail ? e : new SitefileError(e.code, detail, e.span);
+    return detail === e.detail ? e : new SitefileError(e.code, detail, e.span, e.needs ? { needs: e.needs } : undefined);
 }
 /** The request headers of an import's SECRET clauses; a secret that was not given is E_SECRET. */
 export function secretHeaders(spec, secrets) {

package/lib/src/serve-rules.js

@@ -100,7 +100,8 @@ export function globMatch(pattern, s) {
 }
 /** Every matching block's headers; a name set by several blocks gets its values joined with `, `. */
 export function headersFor(rules, path) {
-    const out = {};
+    // No prototype: a header named `__proto__` is an ordinary name (as in the Rust port).
+    const out = Object.create(null);
     for (const r of rules) {
         if (!globMatch(r.pattern, path))
             continue;

package/lib/src/servers.d.ts

@@ -1,3 +1,4 @@
+import { type ArchiveLimits } from './resources/types.js';
 import { Store } from './store.js';
 import { Tree } from './tree.js';
 /**
@@ -22,6 +23,11 @@ export interface ServerState {
     } | {
         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). */
@@ -67,5 +73,13 @@ export declare function pidAlive(pid: number): boolean;
 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

@@ -2,8 +2,12 @@ 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}$/;
@@ -125,15 +129,97 @@ export async function isRunning(s) {
         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');
-    const visible = tree.entries().filter(([p]) => p.split('/').every((seg) => !seg.startsWith('.') || seg === '' || seg === '.well-known'));
-    return Tree.fromFiles(visible);
+    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) {
-    return source.kind === 'image' ? store.loadTree(source.imageId) : loadDirectoryTree(source.path);
+    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/vendor.js

@@ -104,7 +104,7 @@ async function vendorUnredacted(options) {
             lock,
             frozen,
             update,
-            registry: { ...options.registry, allowPrivateNetwork: options.registry?.allowPrivateNetwork ?? policy.allowPrivateNetwork },
+            registry: { ...options.registry, allowPrivateNetwork: options.registry?.allowPrivateNetwork ?? policy.allowPrivateNetwork, network: options.registry?.network ?? policy.network },
             warn,
             lead,
             enforcePlatform,

package/lib/src/wbn.d.ts

@@ -3,3 +3,24 @@ export declare function mimeTypeFor(path: string): string;
 /** An absolute https URL ending in `/`, without credentials, query or fragment. Returns its normalized form. */
 export declare function validateBaseUrl(raw: string | undefined): string;
 export declare function writeWebBundle(tree: Tree, baseUrl: string | undefined): Uint8Array;
+/**
+ * The responses section and its URLs (tree paths, percent-encoded by the caller), as `sitefile
+ * serve` would answer them:
+ *
+ * - Each file is a 200 with `content-type` and the `/_headers` blocks whose pattern matches its
+ *   URL path (`headersFor`; a `content-type` there replaces the inferred one). A directory URL
+ *   (`/docs/` for `/docs/index.html`) matches with its trailing slash, so it gets its own
+ *   response when its headers differ from the file URL's.
+ * - An exact-path `/_redirects` rule with a 3xx status becomes a response with that `:status`, a
+ *   `location` of the rule's target as written, and an empty body: at its path when no file
+ *   would be served there, and over the file when forced (`301!`). Like `serve`, the first rule
+ *   matching the path decides; when that is a splat or a 200/404 rewrite, the bundle leaves the
+ *   path to `/_redirects`. Splat rules and rewrites are not baked in.
+ *
+ * `/_headers` and `/_redirects` stay in the bundle as files. Responses are deduplicated (both URLs
+ * of an index page share one when their headers agree; identical redirects share one).
+ */
+export declare function bundleResponses(tree: Tree): {
+    responses: Uint8Array[];
+    urls: Array<[string, number]>;
+};