partial-content 1.0.0

package/dist/kernel.d.ts

@@ -0,0 +1,541 @@
+/**
+ * HTTP Range header parser and response builder (RFC 7233 + RFC 9110).
+ *
+ * Pure functions for building RFC-compliant HTTP responses that serve
+ * files from any storage backend (S3, R2, GCS, local disk). Handles
+ * range parsing, conditional request evaluation, and response header
+ * construction.
+ *
+ * Supports:
+ *   - `If-None-Match` -> 304 Not Modified (bandwidth savings on revisits)
+ *   - `If-Match` / `If-Unmodified-Since` -> 412 Precondition Failed
+ *   - `If-Range` -> ETag/date validation (prevents data corruption)
+ *   - `Range: bytes=...` -> 206 Partial Content (seeking in video/PDF)
+ *   - 416 Range Not Satisfiable (proper error for unsatisfiable ranges)
+ *
+ * Supports both single byte ranges and multiple ranges (`parseRanges` +
+ * the `multipart/byteranges` builders below). Multi-range coalesces
+ * overlapping/adjacent parts and caps the count (amplification defense); the
+ * single-range fast path is kept separate so the common seek pays no
+ * multi-range overhead.
+ */
+/** A validated, clamped byte range with inclusive bounds. */
+export interface ParsedRange {
+    /** First byte position (0-indexed). */
+    start: number;
+    /**
+     * Last byte position (inclusive). May equal {@link OPEN_ENDED} on the
+     * single-round-trip fast path, meaning "to end of object" -- the range's
+     * true end is unknown until the backend responds. Adapters MUST treat
+     * `end === OPEN_ENDED` as an open-ended read (`bytes=start-`, or omit the
+     * count) rather than emitting the sentinel as a literal last-byte-pos.
+     */
+    end: number;
+}
+/**
+ * Sentinel `ParsedRange.end` meaning "to the end of the object". Used only
+ * by the fast path for a `bytes=a-` request, where the total size is not yet
+ * known. It is deliberately NOT `Number.MAX_SAFE_INTEGER`-as-a-magic-number
+ * at call sites: adapters compare against this named constant and emit the
+ * idiomatic open-ended wire form, so no 16-digit last-byte-pos ever reaches
+ * a backend or proxy that might reject it.
+ */
+export declare const OPEN_ENDED: number;
+/** True when a range is the fast-path open-ended form (`bytes=start-`). */
+export declare function isOpenEndedRange(range: {
+    end: number;
+} | undefined | null): boolean;
+/** Options for building range response headers. */
+export interface RangeResponseHeaderOpts {
+    /**
+     * Total object size in bytes, or `undefined` when the total is unknown --
+     * a `bytes a-b/*` partial response from a streaming origin that does not
+     * know its full length (RFC 7233 Section 4.2). Unknown is valid ONLY
+     * alongside a `range`: a 206's `Content-Length` is the range span, so the
+     * total is not needed to size the body and is emitted as `*`. A full (200)
+     * response has no length without it and rejects `undefined`.
+     */
+    totalSize: number | undefined;
+    /** Parsed range, or null for a full-content response. */
+    range: ParsedRange | null;
+    /** MIME type from storage metadata. */
+    contentType: string | undefined;
+    /** ETag from storage metadata, for conditional caching. */
+    etag: string | undefined;
+    /**
+     * Last-Modified date from storage metadata.
+     *
+     * Accepts any string parseable by `Date.parse()` (ISO 8601, IMF-fixdate,
+     * RFC 850, asctime). The library normalizes it to IMF-fixdate
+     * (e.g. "Sun, 29 Jun 2025 12:00:00 GMT") before emitting the
+     * `Last-Modified` response header, because ISO strings are not valid
+     * HTTP-dates and would break `If-Modified-Since` revalidation.
+     */
+    lastModified: string | undefined;
+    /**
+     * RFC 9530 representation digest for end-to-end integrity.
+     *
+     * When provided, emitted as `Repr-Digest: sha-256=:<base64>:` on 200/206
+     * responses. The digest covers the *full representation* (not the partial
+     * range), so it remains stable across range requests.
+     *
+     * Storage backends typically provide this:
+     * - S3: `x-amz-checksum-sha256`
+     * - GCS: `x-goog-hash: crc32c=...,md5=...`
+     *
+     * Must be a raw base64-encoded SHA-256 hash (no prefix, no colons).
+     */
+    digest?: string;
+    /**
+     * Cache-Control directive to include in the response.
+     *
+     * The library never generates cache directives on its own. It only echoes
+     * a value you provide. Common patterns:
+     *   - `"private, no-cache"` (revalidate every request)
+     *   - `"private, max-age=3600"` (cache 1 hour)
+     *   - `"public, max-age=31536000, immutable"` (content-addressed)
+     */
+    cacheControl?: string;
+}
+/** Result of building range response headers. */
+export interface RangeResponseHeaders {
+    /** HTTP status code: 200 for full content, 206 for partial, 304 for not modified, 412 for precondition failure, 416 for unsatisfiable. */
+    status: 200 | 206 | 304 | 412 | 416;
+    /** Headers to set on the response. */
+    headers: Record<string, string>;
+}
+/** Result of the full conditional request evaluation chain. */
+export interface EvaluatedRequest extends RangeResponseHeaders {
+    /** Parsed range, or null if full content or an error status. */
+    range: ParsedRange | null;
+}
+/**
+ * Parse an HTTP Range header value into a validated byte range.
+ *
+ * Supports three RFC 7233 forms:
+ *   - `bytes=0-499`   (first 500 bytes)
+ *   - `bytes=500-`    (everything from byte 500 onward)
+ *   - `bytes=-500`    (last 500 bytes, suffix range)
+ *
+ * Returns `null` for:
+ *   - Missing or empty header
+ *   - Malformed syntax
+ *   - Multi-range requests (e.g. `bytes=0-100,200-300`)
+ *   - Non-byte range units
+ *
+ * Returns `"unsatisfiable"` for:
+ *   - Start >= totalSize (valid syntax but out of bounds)
+ *   - Suffix of 0 bytes
+ *   - Start > end after clamping
+ *
+ * This distinction matters: `null` means "not a range request" (serve 200),
+ * while `"unsatisfiable"` means "valid range syntax but cannot be honored" (serve 416).
+ *
+ * @param rangeHeader - The raw `Range` header value (e.g. "bytes=0-499")
+ * @param totalSize - Total file size in bytes
+ */
+export declare function parseRangeHeader(rangeHeader: string | null | undefined, totalSize: number): ParsedRange | "unsatisfiable" | null;
+/** Default cap on distinct coalesced ranges before a request degrades to 200. */
+export declare const MAX_RANGES_DEFAULT = 50;
+/** A validated, coalesced set of satisfiable ranges. */
+export interface RangeSet {
+    /**
+     * Coalesced satisfiable ranges in ascending order (length >= 1). A length
+     * of 1 is served as a normal single 206; length > 1 as multipart/byteranges.
+     */
+    ranges: ParsedRange[];
+}
+/**
+ * Parse a possibly-multi-range `Range` header into a coalesced, satisfiable
+ * range set, applying range-amplification defenses.
+ *
+ * Return contract mirrors {@link parseRangeHeader} but for a set:
+ *   - `null`          -- not a byte range, ignorable syntax, or a defense
+ *                        tripped: serve the full 200.
+ *   - `"unsatisfiable"` -- every element was valid syntax but out of bounds:
+ *                        serve 416.
+ *   - {@link RangeSet} -- 1+ satisfiable ranges (overlapping/adjacent already
+ *                        coalesced): serve 206 (single) or multipart (>1).
+ *
+ * Amplification defenses (informed by Go `net/http.ServeContent`'s
+ * sum-of-ranges check and nginx `max_ranges` + adjacent coalescing):
+ *   1. Overlapping/adjacent ranges are coalesced, so a client cannot force
+ *      redundant bytes by requesting the same region many times.
+ *   2. If the coalesced set still exceeds `maxRanges` distinct parts, or the
+ *      bytes it covers reach or exceed the whole representation, the ranges
+ *      are ignored and the full 200 is served -- multipart framing over the
+ *      entire file is pure overhead and a classic amplification vector.
+ *
+ * Empty list elements (`bytes=0-1,,2-3`) are skipped per the RFC 9110
+ * Section 5.6.1 list rule; a genuinely malformed element voids the whole
+ * header (serve 200), matching single-range leniency.
+ */
+export declare function parseRanges(rangeHeader: string | null | undefined, totalSize: number, maxRanges?: number): RangeSet | "unsatisfiable" | null;
+/**
+ * Generate a multipart/byteranges boundary token. Hyphen-free so the token
+ * itself can never contain the `--` delimiter run; random so it cannot appear
+ * in body content by construction.
+ */
+export declare function generateMultipartBoundary(): string;
+/**
+ * Build the per-part header block for one multipart/byteranges part:
+ * `--BOUNDARY CRLF [Content-Type CRLF] Content-Range CRLF CRLF`. The part's
+ * body bytes and a trailing CRLF follow (the caller emits those).
+ */
+export declare function buildMultipartPartHeader(boundary: string, range: ParsedRange, totalSize: number, contentType: string | undefined): string;
+/** The closing delimiter for a multipart/byteranges body: `--BOUNDARY-- CRLF`. */
+export declare function multipartEpilogue(boundary: string): string;
+/** Result of {@link buildMultipartHeaders}. */
+export interface MultipartResponse {
+    status: 206;
+    headers: Record<string, string>;
+    /** Exact byte length of the full multipart body (framing + all part bytes). */
+    contentLength: number;
+}
+/**
+ * Build the top-level headers and exact Content-Length for a
+ * multipart/byteranges (206) response. The per-representation Content-Type
+ * lives in each part; the top-level type is `multipart/byteranges`.
+ *
+ * Content-Length is computed deterministically from the framing and the
+ * range spans, so the response is never chunked and the client gets an exact
+ * length up front. `contentType` is the representation's own MIME (placed in
+ * every part header).
+ */
+export declare function buildMultipartHeaders(opts: {
+    boundary: string;
+    ranges: ParsedRange[];
+    totalSize: number;
+    contentType: string | undefined;
+    etag?: string;
+    lastModified?: string;
+    cacheControl?: string;
+    digest?: string;
+}): MultipartResponse;
+/**
+ * Check if a conditional GET request is "fresh" (resource not modified).
+ *
+ * Implements RFC 7232 Section 3.2 (If-None-Match) and Section 3.3
+ * (If-Modified-Since). `If-None-Match` takes precedence per the spec.
+ *
+ * When this returns true, the server should respond with 304 Not Modified
+ * and skip streaming the body entirely.
+ *
+ * @param reqHeaders - Request headers (must support `.get(name)`)
+ * @param etag - Current resource ETag
+ * @param lastModified - Current resource Last-Modified date string
+ */
+export declare function isConditionalFresh(reqHeaders: {
+    get(name: string): string | null;
+}, etag: string | undefined, lastModified: string | undefined): boolean;
+/**
+ * Check if a request's preconditions have failed.
+ *
+ * Implements RFC 7232 Section 3.1 (If-Match) and Section 3.4
+ * (If-Unmodified-Since). `If-Match` takes precedence per the spec.
+ *
+ * When this returns true, the server MUST respond with 412 Precondition
+ * Failed and skip processing the request body.
+ *
+ * Evaluation order per RFC 7232 Section 6:
+ *   1. isPreconditionFailure -> 412 (this function)
+ *   2. isConditionalFresh    -> 304
+ *   3. Process range / serve content
+ *
+ * @param reqHeaders - Request headers (must support `.get(name)`)
+ * @param etag - Current resource ETag
+ * @param lastModified - Current resource Last-Modified date string
+ * @param exists - Whether the resource currently exists. When omitted,
+ *   inferred from `etag !== undefined`. Callers that have already fetched
+ *   metadata (e.g. the read orchestrator) should pass `true` explicitly.
+ */
+export declare function isPreconditionFailure(reqHeaders: {
+    get(name: string): string | null;
+}, etag: string | undefined, lastModified: string | undefined, exists?: boolean): boolean;
+/**
+ * Check if a Range request's `If-Range` precondition is "fresh".
+ *
+ * RFC 7233 Section 3.2: If the client sends `If-Range`, the server MUST
+ * only honor the Range when the validator matches. If it doesn't match,
+ * the resource has changed since the client cached it, so serving a partial
+ * response would result in data corruption (new bytes appended to old content).
+ *
+ * Returns `true` if the Range should be honored (validator matches or no If-Range).
+ * Returns `false` if the Range should be ignored (serve full 200 instead).
+ *
+ * @param reqHeaders - Request headers
+ * @param etag - Current resource ETag
+ * @param lastModified - Current resource Last-Modified date string
+ */
+export declare function isRangeFresh(reqHeaders: {
+    get(name: string): string | null;
+}, etag: string | undefined, lastModified: string | undefined): boolean;
+/**
+ * Build HTTP response headers for a full or partial content response.
+ *
+ * Always includes `Accept-Ranges: bytes` to advertise range support
+ * (even on 200 responses, per RFC 7233 Section 2.3).
+ *
+ * Handles:
+ *   - 200 OK (full content, when range is null)
+ *   - 206 Partial Content (valid range)
+ *
+ * For error statuses (304, 412, 416), use the dedicated builders
+ * (`build304Headers`, `build412Headers`, `build416Headers`).
+ *
+ * @returns Status code and headers dict ready to pass to `new Response()`.
+ */
+export declare function buildRangeResponseHeaders(opts: RangeResponseHeaderOpts): RangeResponseHeaders;
+/**
+ * Build 416 Range Not Satisfiable response headers.
+ *
+ * Per RFC 7233 Section 4.4, the response MUST include a Content-Range
+ * header with the unsatisfied-range syntax: `bytes * /totalSize`.
+ *
+ * Deliberately omits ETag, Last-Modified, and Content-Type. These are
+ * representation metadata for the successful response; including them
+ * on error responses can poison shared caches.
+ */
+export declare function build416Headers(totalSize: number): RangeResponseHeaders;
+/** Result of parsing a Content-Range response header. */
+export interface ParsedContentRange {
+    /** First byte of the range (inclusive, 0-indexed). */
+    start: number;
+    /** Last byte of the range (inclusive). */
+    end: number;
+    /** Total size of the complete representation. */
+    totalSize: number;
+}
+/**
+ * Parse a `Content-Range` response header into structured fields.
+ *
+ * Understands the two RFC 7233 Section 4.2 forms:
+ *   - `bytes 0-499/1000` (byte range with known total)
+ *   - `bytes 0-499/*`    (byte range with unknown total, returns `totalSize: -1`)
+ *
+ * The unsatisfied-range form (`bytes * /1000`) is NOT parsed because it carries
+ * no range information -- callers should check the HTTP status (416) instead.
+ *
+ * Returns `null` for:
+ *   - Missing or empty header
+ *   - Non-byte range units
+ *   - Malformed syntax
+ *   - Unsatisfied range form (`bytes * /...`)
+ *
+ * Storage adapters use this to extract `totalSize` from a 206 response when
+ * the backend serves a range slice. Without it, each adapter reimplements the
+ * same regex inline, with varying correctness on edge cases.
+ *
+ * @example
+ * ```typescript
+ * import { parseContentRange } from "partial-content";
+ *
+ * const cr = parseContentRange("bytes 0-499/1000");
+ * // => { start: 0, end: 499, totalSize: 1000 }
+ *
+ * const unknown = parseContentRange("bytes 0-499/*");
+ * // => { start: 0, end: 499, totalSize: -1 }
+ * ```
+ */
+export declare function parseContentRange(header: string | null | undefined): ParsedContentRange | null;
+/**
+ * Build 412 Precondition Failed response headers.
+ *
+ * Per RFC 7232 Section 4.2, a 412 response indicates that one or more
+ * conditions in the request headers (If-Match, If-Unmodified-Since)
+ * evaluated to false.
+ *
+ * Deliberately omits representation metadata (ETag, Last-Modified,
+ * Content-Type) to prevent cache poisoning.
+ */
+export declare function build412Headers(): RangeResponseHeaders;
+/**
+ * Build 304 Not Modified response headers.
+ *
+ * Per RFC 7232 Section 4.1, a 304 response MUST NOT contain a message
+ * body and SHOULD NOT include representation headers (Content-Type,
+ * Content-Length, Content-Encoding, Content-Language, Content-Range).
+ *
+ * Only includes: ETag, Last-Modified, and Cache-Control.
+ */
+export declare function build304Headers(etag: string | undefined, lastModified: string | undefined, cacheControl?: string): RangeResponseHeaders;
+/**
+ * Evaluate a conditional request and return the correct HTTP response.
+ *
+ * Implements the full RFC 7232 Section 6 evaluation chain in the correct
+ * order. This is the recommended entry point for most consumers -- it
+ * eliminates the risk of misordering the evaluation steps.
+ *
+ * Evaluation order:
+ *   1. `isPreconditionFailure` -> 412 Precondition Failed
+ *   2. `isConditionalFresh`    -> 304 Not Modified
+ *   3. `isRangeFresh`          -> Should we honor the Range?
+ *   4. `parseRangeHeader`      -> Parse and validate the Range
+ *   5. `buildRangeResponseHeaders` or `build416Headers`
+ *
+ * @returns Status, headers, and the parsed range (null if full content or error status).
+ */
+export declare function evaluateConditionalRequest(reqHeaders: {
+    get(name: string): string | null;
+}, meta: {
+    totalSize: number;
+    contentType?: string;
+    etag?: string;
+    lastModified?: string;
+    cacheControl?: string;
+    /** RFC 9530 SHA-256 digest (raw base64, no prefix). Emitted as `Repr-Digest` on 200/206. */
+    digest?: string;
+}): EvaluatedRequest;
+/**
+ * Result of a conditional-write evaluation.
+ *
+ * Discriminated union on `proceed`:
+ * - `{ proceed: true }` -- safe to execute the write.
+ * - `{ proceed: false, status: 412, headers }` -- return 412 to the client.
+ */
+export type EvaluatedWrite = {
+    proceed: true;
+} | {
+    proceed: false;
+    status: 412;
+    headers: Record<string, string>;
+};
+/**
+ * Evaluate conditional headers for a **write** request (PUT, PATCH, DELETE).
+ *
+ * On read requests (GET/HEAD), `If-None-Match` match triggers 304 Not Modified.
+ * On write requests, the same match triggers **412 Precondition Failed**
+ * (RFC 9110 Section 13.1.2). This function implements the write-side
+ * evaluation so consumers don't accidentally use the read-side orchestrator
+ * for OCC flows.
+ *
+ * Evaluation order (RFC 9110 Section 13.2.2):
+ *   1. `If-Match` / `If-Unmodified-Since` -> 412 (same as reads)
+ *   2. `If-None-Match`                    -> 412 (differs from reads: 412, not 304)
+ *
+ * ### OCC pattern (If-Match)
+ *
+ * ```typescript
+ * const result = evaluateConditionalWrite(req.headers, {
+ *   etag: '"v2"',
+ *   lastModified: "2025-06-28T12:00:00.000Z",
+ * });
+ * if (!result.proceed) {
+ *   return new Response(null, { status: result.status, headers: result.headers });
+ * }
+ * // Safe to apply the mutation
+ * ```
+ *
+ * ### PUT-if-absent pattern (If-None-Match: *)
+ *
+ * ```typescript
+ * const result = evaluateConditionalWrite(req.headers, {
+ *   etag: existingEtag, // undefined if resource doesn't exist yet
+ *   exists: resourceExists,
+ * });
+ * ```
+ *
+ * @param reqHeaders - Request headers (must support `.get(name)`)
+ * @param meta - Current resource state
+ */
+export declare function evaluateConditionalWrite(reqHeaders: {
+    get(name: string): string | null;
+}, meta: {
+    etag?: string;
+    lastModified?: string;
+    /**
+     * Whether the target resource currently exists. Used to evaluate
+     * `If-None-Match: *` (PUT-if-absent / create-only pattern).
+     *
+     * When omitted, existence is inferred from `etag !== undefined`.
+     */
+    exists?: boolean;
+}): EvaluatedWrite;
+/**
+ * Adapter for Node.js HTTP servers (Express, Fastify, raw `http`).
+ *
+ * Converts a plain Node headers object (`IncomingHttpHeaders`) into the
+ * `{ get(name) }` interface expected by `partial-content` functions.
+ *
+ * @example
+ * ```typescript
+ * import { fromNodeHeaders, isConditionalFresh } from "partial-content";
+ *
+ * // Express
+ * app.get("/file", (req, res) => {
+ *   const headers = fromNodeHeaders(req.headers);
+ *   if (isConditionalFresh(headers, etag, lastModified)) {
+ *     return res.status(304).end();
+ *   }
+ * });
+ * ```
+ */
+export declare function fromNodeHeaders(headers: Record<string, string | string[] | undefined>): {
+    get(name: string): string | null;
+};
+/** Metadata from a storage backend used to derive an entity-tag. */
+export interface ETagSource {
+    /**
+     * Content digest from the backend (S3/Azure/GCS object hash).
+     * Yields a STRONG validator. May include surrounding quotes or `W/` prefix,
+     * both of which are normalized.
+     */
+    hash?: string;
+    /** Object size in bytes. With `mtime`, yields a WEAK validator when no hash exists. */
+    size?: number;
+    /**
+     * Last-modified: `Date`, epoch-ms number, or any `Date.parse()`-able string.
+     * Floor to whole seconds for consistency with emitted `Last-Modified` headers.
+     */
+    mtime?: Date | number | string;
+}
+/**
+ * Derive an entity-tag from storage metadata.
+ *
+ * This is a **formatter**, not a hasher. It classifies what the storage backend
+ * already provides into the correct validator strength per RFC 9110 Section 8.8.1:
+ *
+ * - `hash` present        -> strong `"<hash>"` (a content digest asserts byte equality)
+ * - `size` + `mtime` only -> weak `W/"<size>-<mtime>"` (cannot assert byte equality;
+ *                            mtime resolution is coarse, collisions exist)
+ * - insufficient metadata -> `undefined` (caller omits ETag; never fabricate a
+ *                            validator we cannot stand behind)
+ *
+ * The dangerous failure mode is emitting a strong or size-only validator that ignores
+ * modification, which would serve stale 304s. Every `undefined` return guards that.
+ *
+ * @param source - Storage metadata to derive the ETag from
+ * @returns A correctly-typed ETag string, or `undefined` if insufficient metadata
+ */
+export declare function generateETag(source: ETagSource): string | undefined;
+/**
+ * Strip bytes outside RFC 9110 field-value grammar to prevent HTTP header
+ * injection (CWE-113) and header-write crashes.
+ *
+ * Storage backends may pass through untrusted ETag, Last-Modified,
+ * Content-Type, digest, Cache-Control, or Location values. Exported so
+ * framework adapters can sanitize backend-derived headers the kernel does
+ * not build itself (e.g. the web adapter's signed-URL `Location`).
+ */
+export declare function sanitizeHeaderValue(s: string): string;
+/**
+ * RFC 9530 Section 4: Check if the client wants a `sha-256` digest.
+ *
+ * `Want-Repr-Digest` uses Structured Fields Dictionary syntax:
+ *   Want-Repr-Digest: sha-256=5, sha-512=3
+ *
+ * Each key is a hash algorithm, each value is a preference weight (0-10).
+ * Weight 0 means "explicitly unwanted." If the header is absent or contains
+ * `sha-256` with weight > 0, we emit the digest. If it only lists algorithms
+ * we don't support (e.g. `sha-512=5`), we skip emission entirely.
+ *
+ * We also check `Want-Content-Digest` since our Content-Digest uses the
+ * same algorithm.
+ *
+ * Exported so framework adapters apply the same negotiation the orchestrator
+ * uses internally -- digest emission behaves identically at every layer.
+ */
+export declare function clientWantsDigest(reqHeaders: {
+    get(name: string): string | null;
+}): boolean;
+//# sourceMappingURL=kernel.d.ts.map

package/dist/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../src/kernel.ts"],"names":[],"mappings":"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"}