partial-content 1.0.0

package/dist/content-disposition.js

@@ -0,0 +1,253 @@
+/**
+ * Content-Disposition header builder (RFC 6266 + RFC 8187).
+ *
+ * Builds Content-Disposition headers for HTTP responses that serve files.
+ * Handles both inline (in-app preview) and attachment (download) dispositions
+ * with proper RFC compliance for non-ASCII filenames.
+ *
+ * Security: Prevents CRLF header injection, path traversal, bidi override
+ * spoofing, and control character injection in filenames from untrusted
+ * sources (integration APIs, user uploads).
+ *
+ * Emits dual filename parameters for cross-browser compatibility:
+ *   - `filename="ascii-safe.pdf"` for legacy browsers
+ *   - `filename*=UTF-8''%C3%85rlig.pdf` for modern browsers (RFC 8187)
+ */
+// ─── Constants ──────────────────────────────────────────────────────────────
+/**
+ * RFC 2616 token characters. A filename that matches this pattern can be
+ * emitted unquoted in the `filename=` parameter (e.g. `filename=plans.pdf`).
+ * Anything outside this set requires quoted-string encoding.
+ *
+ * token = 1*<any CHAR except CTLs or separators>
+ * separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <">
+ *            | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT
+ */
+const TOKEN_REGEXP = /^[!#$%&'*+.0-9A-Z^_`a-z|~-]+$/;
+/**
+ * Characters that are valid US-ASCII text (printable range 0x20-0x7E).
+ * Filenames matching this can use the simple `filename=` parameter with
+ * quoted-string encoding. Non-ASCII filenames need `filename*=` (RFC 8187).
+ */
+const ASCII_TEXT_REGEXP = /^[\x20-\x7e]*$/;
+/**
+ * Characters that need escaping inside an RFC 2616 quoted-string.
+ * Per Section 2.2: quoted-pair = "\" CHAR, and the only characters
+ * that MUST be escaped are `\` and `"`.
+ */
+const QUOTED_PAIR_REGEXP = /[\\"]/g;
+/**
+ * Characters that are not valid in RFC 8187 attr-char, applied AFTER
+ * encodeURIComponent (so `%` is already handled). This catches characters
+ * that encodeURIComponent leaves unescaped but RFC 8187 requires encoded.
+ */
+const ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g; // eslint-disable-line no-control-regex
+/**
+ * Non-US-ASCII characters. Replaced with `?` in the ASCII fallback
+ * for maximum compatibility with legacy HTTP clients.
+ */
+const NON_ASCII_REGEXP = /[^\x20-\x7e]/g;
+/**
+ * Filenames containing percent-encoded sequences (like `the%20plans.pdf`)
+ * should not use the simple `filename=` parameter because legacy clients
+ * may decode them. Force `filename*` for these.
+ */
+const HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
+/**
+ * Matches lone surrogate code units (unpaired high or low surrogates).
+ * These occur when filenames are truncated mid-emoji with .slice().
+ * encodeURIComponent throws URIError on lone surrogates, so we must
+ * strip them before encoding.
+ */
+const LONE_SURROGATE_REGEXP = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+// ─── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Build a Content-Disposition header value with RFC compliance and
+ * security sanitization.
+ *
+ * Accepts untrusted filenames from integration APIs, user uploads, and
+ * database records. Sanitizes for:
+ *   - CRLF injection (strips \r, \n, and all control characters)
+ *   - Path traversal (strips ../ and ..\\ sequences)
+ *   - Basename extraction (strips directory paths)
+ *   - Bidi override stripping (prevents RLO filename spoofing)
+ *   - Double-quote and backslash escaping (RFC 2616 quoted-pair)
+ *
+ * Emits dual filename parameters for cross-browser compatibility:
+ *   - `filename="ascii-safe.pdf"` for legacy browsers (IE, old Safari)
+ *   - `filename*=UTF-8''%C3%85rlig.pdf` for modern browsers (RFC 8187)
+ *
+ * Token optimization: Simple ASCII filenames like `plans.pdf` are emitted
+ * unquoted (`filename=plans.pdf`).
+ *
+ * @param filename - Raw filename from untrusted source (upload, API, DB)
+ * @param options - Disposition type and fallback configuration
+ * @returns Complete Content-Disposition header value string
+ *
+ * @example
+ * // Simple ASCII attachment
+ * buildContentDisposition("report.pdf")
+ * // => 'attachment; filename=report.pdf'
+ *
+ * @example
+ * // Non-ASCII filename (Danish)
+ * buildContentDisposition("Årlig_Rapport.pdf")
+ * // => 'attachment; filename="?rlig_Rapport.pdf"; filename*=UTF-8\'\'%C3%85rlig_Rapport.pdf'
+ *
+ * @example
+ * // Inline disposition for preview
+ * buildContentDisposition("slides.pdf", { type: "inline" })
+ * // => 'inline; filename=slides.pdf'
+ *
+ * @example
+ * // Null input with custom fallback
+ * buildContentDisposition(null, { fallback: "export.csv" })
+ * // => 'attachment; filename=export.csv'
+ */
+export function buildContentDisposition(filename, options) {
+    // Never trust the disposition type: a JS caller (or a mistyped
+    // `disposition` extractor returning a computed string) could otherwise
+    // smuggle header parameters through it. Anything but "inline" is
+    // "attachment" -- the safe default.
+    const type = options?.type === "inline" ? "inline" : "attachment";
+    // Sanitize BOTH the untrusted filename and the fallback through the same
+    // cleaner, then fall back to a constant. A filename that reduces to
+    // nothing (only controls/bidi/path components) must NOT emit a raw
+    // fallback into filename* -- that path leaked un-neutralized bidi
+    // overrides, defeating the anti-spoofing guarantee.
+    const sanitized = sanitizeFilename(filename ?? "")
+        || sanitizeFilename(options?.fallback ?? "")
+        || "document";
+    return `${type}${buildFilenameParams(sanitized)}`;
+}
+// ─── Internal Helpers ───────────────────────────────────────────────────────
+/**
+ * Sanitize an untrusted filename for safe use in HTTP headers.
+ *
+ * Applied BEFORE any RFC encoding. This is the security layer that
+ * prevents header injection and path traversal attacks.
+ */
+function sanitizeFilename(raw) {
+    // 1. Strip control characters and Unicode formatting controls.
+    //    C0 controls (\x00-\x1F), DEL (\x7F): prevents CRLF header injection.
+    //    C1 controls (\x80-\x9F): invisible formatting, no valid use in filenames.
+    //    Bidi overrides (U+202A-202E, U+2066-2069): prevents RLO filename
+    //    spoofing where "report\u202Efdp.exe" renders as "reportexe.pdf".
+    //    Zero-width chars (U+200B-200F): invisible joiners/marks, strips
+    //    directional marks that could confuse filename display.
+    //    NBSP (U+00A0): often mistaken for regular space, normalize away.
+    const noControls = raw.replace(/[\r\n\x00-\x1F\x7F\x80-\x9F\u00A0\u200B-\u200F\u2028\u2029\u202A-\u202E\u2066-\u2069]/g, "");
+    // 2. Strip path traversal sequences (../ and ..\).
+    //    Some integration APIs return full paths or relative paths.
+    //    Even though HTTP clients shouldn't interpret these, defense-in-depth.
+    const noTraversal = noControls.replace(/\.\.[/\\]/g, "");
+    // 3. Extract basename (strip directory components).
+    //    Integration APIs sometimes return full paths like "/uploads/2024/report.pdf".
+    //    Uses lastIndexOf instead of split().pop() to avoid array allocation.
+    const lastSep = Math.max(noTraversal.lastIndexOf("/"), noTraversal.lastIndexOf("\\"));
+    const basename = lastSep >= 0 ? noTraversal.slice(lastSep + 1) : noTraversal;
+    // May be empty: the caller composes the fallback chain so both the
+    // filename and the fallback pass through this same sanitizer.
+    return basename;
+}
+/**
+ * Build the filename parameter string for Content-Disposition.
+ *
+ * Encoding strategy:
+ *   1. Pure ASCII token (no separators): emit unquoted `filename=report.pdf`
+ *   2. ASCII with special chars: emit quoted `filename="my report.pdf"`
+ *   3. Non-ASCII: emit both `filename="?rlig.pdf"` and `filename*=UTF-8''...`
+ *
+ * RFC 2616 Section 2.2 quoted-string escaping:
+ *   - `\` -> `\\` (backslash must be escaped)
+ *   - `"` -> `\"` (double-quote must be escaped)
+ */
+function buildFilenameParams(filename) {
+    // Case 1: Pure ASCII that fits in a token -- emit unquoted.
+    // Also reject filenames with hex-encoded sequences (%20) which could
+    // be decoded by legacy clients.
+    if (ASCII_TEXT_REGEXP.test(filename) && !HEX_ESCAPE_REGEXP.test(filename)) {
+        if (TOKEN_REGEXP.test(filename)) {
+            return `; filename=${filename}`;
+        }
+        // ASCII but contains separators/spaces -- use quoted-string
+        return `; filename=${quoteString(filename)}`;
+    }
+    // Case 2: Contains non-ASCII characters or hex escapes.
+    // Emit both parameters for cross-browser compatibility:
+    //   - filename="ascii-fallback" for legacy clients
+    //   - filename*=UTF-8''percent-encoded for modern clients (RFC 8187)
+    const asciiFallback = toAsciiFallback(filename);
+    const encoded = encodeRfc8187(filename);
+    // When filename has hex escapes but is pure ASCII, we still need
+    // filename* because the hex escape could be decoded by legacy clients.
+    // Percent-encode % in the fallback to prevent unintended decoding.
+    const safeFallback = asciiFallback.replace(/%/g, "%25");
+    if (TOKEN_REGEXP.test(safeFallback)) {
+        return `; filename=${safeFallback}; filename*=${encoded}`;
+    }
+    return `; filename=${quoteString(safeFallback)}; filename*=${encoded}`;
+}
+/**
+ * Quote a string per RFC 2616 Section 2.2.
+ *
+ * quoted-string = ( <"> *(qdtext | quoted-pair) <"> )
+ * quoted-pair   = "\" CHAR
+ *
+ * Both `\` and `"` MUST be escaped with a preceding backslash.
+ *
+ * In practice, `\` is stripped by sanitizeFilename (treated as path separator),
+ * so only `"` escaping is exercised through the normal code path. The `\`
+ * escaping is defense-in-depth for correctness if sanitization ever changes.
+ */
+function quoteString(str) {
+    return `"${str.replace(QUOTED_PAIR_REGEXP, "\\$&")}"`;
+}
+/**
+ * Generate a US-ASCII fallback for non-ASCII filenames.
+ *
+ * Replaces non-ASCII characters with `?`. This is more honest than `_` --
+ * it signals to the user that characters were lost in translation, rather
+ * than suggesting underscores were in the original.
+ */
+function toAsciiFallback(filename) {
+    return filename.replace(NON_ASCII_REGEXP, "?");
+}
+/**
+ * Encode a string per RFC 8187 (formerly RFC 5987).
+ *
+ * Format: charset'language'value-chars
+ * We always use UTF-8 and leave language empty.
+ *
+ * The encoding differs from encodeURIComponent in that RFC 8187
+ * defines its own set of "attr-char" that don't need encoding.
+ * We first apply encodeURIComponent (which handles all non-ASCII),
+ * then encode the characters that encodeURIComponent leaves unescaped
+ * but RFC 8187 requires encoded (including single quotes, which are
+ * the charset/language delimiter in the RFC 8187 format).
+ */
+function encodeRfc8187(str) {
+    // encodeURIComponent itself throws URIError on lone surrogates
+    // (ECMA-262), so the exception IS the surrogate detector: clean strings
+    // (the overwhelming majority, including valid emoji pairs) pay no
+    // pre-scan at all. Lone surrogates only occur when upstream code
+    // truncates filenames mid-emoji with .slice() on UTF-16 code units;
+    // that pathological path eats the exception cost and retries stripped.
+    // Benchmarked against a surrogate-range pre-scan regex: this is ~6x
+    // faster for emoji filenames (a pre-scan cannot tell valid pairs from
+    // lone surrogates, so it triggered the strip for every emoji).
+    let encoded;
+    try {
+        encoded = encodeURIComponent(str);
+    }
+    catch {
+        encoded = encodeURIComponent(str.replace(LONE_SURROGATE_REGEXP, ""));
+    }
+    encoded = encoded.replace(ENCODE_URL_ATTR_CHAR_REGEXP, percentEncode);
+    return `UTF-8''${encoded}`;
+}
+/** Percent-encode a single character. */
+function percentEncode(char) {
+    return "%" + char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0");
+}
+//# sourceMappingURL=content-disposition.js.map

package/dist/content-disposition.js.map

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

package/dist/fs.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Local filesystem ObjectStore adapter for partial-content.
+ *
+ * Implements the read-only {@link ObjectStore} interface using Node.js
+ * `fs.stat()` and `fs.createReadStream()`. Suitable for:
+ *   - Development servers
+ *   - Small/medium deployments
+ *   - Hybrid architectures (local cache + cloud primary)
+ *   - Testing and CI pipelines
+ *
+ * Security: all keys are resolved relative to a fixed root directory.
+ * Path traversal attempts (`..`), absolute paths, and null bytes are
+ * rejected with ObjectNotFoundError. Symbolic links inside the root ARE
+ * followed (matching nginx/caddy defaults); do not place untrusted
+ * symlinks under the root if it must be a strict sandbox.
+ *
+ * @example
+ * ```typescript
+ * import { fsStore } from "partial-content/fs";
+ * import { serveObject } from "partial-content/web";
+ *
+ * const store = fsStore({ root: "/var/data/uploads" });
+ *
+ * // Use with the web adapter:
+ * const handler = serveObject(store, { disposition: "inline" });
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { ObjectNotFoundError, type ObjectStore } from "./index.js";
+export { ObjectNotFoundError };
+export interface FsStoreOptions {
+    /**
+     * Root directory. All keys are resolved relative to this path.
+     * Must be an absolute path.
+     */
+    root: string;
+    /**
+     * Opt-in hot-object cache (metadata + small bodies), following the
+     * nginx `open_file_cache` model: entries revalidate on a TTL rather
+     * than a change watcher, so a served representation can lag a
+     * filesystem overwrite by up to `ttlMs`. Metadata and bytes are always
+     * captured together from one read, so responses are internally
+     * coherent (headers always describe the bytes actually sent).
+     *
+     * Off by default: correctness-first. Enable for hot small files
+     * (thumbnails, documents, content-addressed assets -- use a long TTL
+     * for immutable keys). Bodies at or below the single-read limit
+     * (128 KiB) are cached; larger objects always stream fresh from disk.
+     *
+     * Memory bound: `maxEntries` caps the entry count and `maxBytes` caps
+     * the total cached BODY bytes, so the worst case is
+     * `min(maxEntries * 128 KiB, maxBytes)` plus per-entry metadata.
+     */
+    cache?: {
+        /** How long an entry may serve before revalidating against disk. */
+        ttlMs: number;
+        /**
+         * Entry cap, evicted least-recently-used.
+         * @default 1024
+         */
+        maxEntries?: number;
+        /**
+         * Total byte budget for cached bodies, evicted least-recently-used.
+         * Metadata-only entries cost nothing against it. A single body larger
+         * than the budget is served normally but cached metadata-only, so an
+         * oversized object can never flush the whole cache to still not fit.
+         * `0` keeps the cache metadata-only (stat elision without body memory).
+         * @default 67108864 (64 MiB)
+         */
+        maxBytes?: number;
+    };
+}
+/**
+ * Create an {@link ObjectStore} backed by the local filesystem.
+ *
+ * @example
+ * ```typescript
+ * import { fsStore } from "partial-content/fs";
+ *
+ * const store = fsStore({ root: "/var/data/uploads" });
+ * const meta = await store.headObject("reports/q4.pdf");
+ * ```
+ */
+export declare function fsStore(opts: FsStoreOptions): ObjectStore;
+//# sourceMappingURL=fs.d.ts.map

package/dist/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,EACL,mBAAmB,EAEnB,KAAK,WAAW,EAIjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAI/B,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,EAAE;QACN,oEAAoE;QACpE,KAAK,EAAE,MAAM,CAAC;QACd;;;WAGG;QACH,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB;;;;;;;WAOG;QACH,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAeD;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,WAAW,CA6TzD"}