@hachej/boring-files 0.4.51 → 0.4.52

package/dist/file-types.d.ts

@@ -12,7 +12,8 @@ export declare const mediaTypeOf: (path: string) => string;
 /** How many leading bytes `sniffMediaType` looks at: a caller reads this many and passes them in. */
 export declare const SNIFF_BYTES = 8192;
 /**
- * The media type a file's leading bytes name, or undefined. Pass up to `SNIFF_BYTES` of them.
+ * The media type a file's leading bytes name, or undefined. Pass at least `SNIFF_BYTES` of them when there are that many; only a zip
+ * looks further, so more bytes (the whole file) let it read its central directory.
  *  - Signatures: PDF, PNG, JPEG, GIF, WebP, HEIC/HEIF and MP4/MOV/M4V (`ftyp` brands), WebM (EBML), and zip-based documents.
  *  - Otherwise `text/plain` when the bytes are valid UTF-8 (a character cut at the end is allowed) with no NUL byte: a weak answer, a
  *    name says better which text it is (`delimitedTextType` for CSV and TSV).

package/dist/file-types.js

@@ -54,44 +54,99 @@ const OOXML_MAIN = [
     ['presentationml.presentation.main', 'ppt/', MEDIA_TYPES.pptx],
 ];
 const ZIP_MIMETYPES = new Set([MEDIA_TYPES.odt, MEDIA_TYPES.ods, MEDIA_TYPES.odp, MEDIA_TYPES.epub]);
+/** The office type a zip's entry names say: a `[Content_Types].xml` and a part in `word/`, `xl/` or `ppt/`, in any order. */
+const officeTypeOf = (names) => names.includes('[Content_Types].xml')
+    ? OOXML_MAIN.find(([, prefix]) => names.some(name => name.startsWith(prefix)))?.[2]
+    : undefined;
+/** How much central directory a zip gets read: a real office file's fits well within this, and the walk is synchronous. */
+const ZIP_DIRECTORY_BYTES = 0x100000;
 /**
- * Zip-based documents from the head alone, without inflating anything: it walks the local file headers that fit in `head`.
- *  - OpenDocument and EPUB: a first entry `mimetype`, stored uncompressed, holds the media type itself.
- *  - Office Open XML (docx, xlsx, pptx): a `[Content_Types].xml` entry, then the main part's content type when that entry is stored
- *    uncompressed, or else the folder of a later entry (`word/`, `xl/`, `ppt/`). Its content is almost always deflated, and inflating
- *    is asynchronous in a browser, so the folder rule is the usual one.
- * A zip whose entries have unknown sizes (a data descriptor) cannot be walked past its first entry; it is then not claimed.
+ * The entry names of a zip's central directory when `bytes` reach its end record; undefined otherwise (a head, a zip64 file, a
+ * directory past the budget). Bytes inside an entry can look like an end record, so only one whose directory adds up counts.
  */
-function sniffZip(head) {
-    let contentTypes = false;
-    for (let offset = 0, index = 0; index < 64 && offset + 30 <= head.length && u32(head, offset) === 0x04034b50; index++) {
-        const flags = u16(head, offset + 6), method = u16(head, offset + 8), size = u32(head, offset + 18);
-        const nameStart = offset + 30, nameEnd = nameStart + u16(head, offset + 26), dataStart = nameEnd + u16(head, offset + 28);
-        if (nameEnd > head.length)
+function zipDirectoryNames(bytes) {
+    let budget = ZIP_DIRECTORY_BYTES;
+    for (let end = bytes.length - 22; end >= 0 && end >= bytes.length - 22 - 0xffff; end--) {
+        if (u32(bytes, end) !== 0x06054b50 || end + 22 + u16(bytes, end + 20) !== bytes.length)
+            continue;
+        const size = u32(bytes, end + 12), start = end - size;
+        if (start < 0 || u32(bytes, end + 16) !== start)
+            continue;
+        budget -= size;
+        if (budget < 0)
             return undefined;
-        const name = ascii(head.subarray(nameStart, nameEnd));
-        const stored = method === 0 && (flags & 8) === 0 && dataStart + size <= head.length ? ascii(head.subarray(dataStart, dataStart + size)) : undefined;
+        const names = [];
+        let offset = start;
+        while (offset + 46 <= end && u32(bytes, offset) === 0x02014b50) {
+            const nameEnd = offset + 46 + u16(bytes, offset + 28);
+            if (nameEnd > end)
+                break;
+            names.push(ascii(bytes.subarray(offset + 46, nameEnd)));
+            offset = nameEnd + u16(bytes, offset + 30) + u16(bytes, offset + 32);
+        }
+        if (offset === end && names.length === u16(bytes, end + 10))
+            return names;
+    }
+    return undefined;
+}
+/**
+ * Zip-based documents from the bytes given, without inflating anything.
+ *  - OpenDocument and EPUB: a first entry `mimetype`, stored uncompressed, holds the media type itself.
+ *  - Office Open XML (docx, xlsx, pptx), whatever the order of its entries (OOXML sets none; openpyxl writes `[Content_Types].xml`
+ *    last): that entry and a part in `word/`, `xl/` or `ppt/`, or the main part's content type when that entry is stored uncompressed.
+ * The answer comes from the local headers while they suffice, then from the central directory when the bytes reach it (the only
+ * place that names entries with unknown sizes). A head of at least `SNIFF_BYTES` that runs out before either: a `.xml` part in an
+ * office folder decides, `[Content_Types].xml` being out of sight. It cannot tell a truncated file from a big one; a host that wants
+ * that refused checks the file's end once it has it. Anything shorter than `SNIFF_BYTES` is the whole file, so it is held to the rule.
+ */
+function sniffZip(bytes) {
+    const names = [];
+    let cut = false;
+    for (let offset = 0, index = 0; offset < bytes.length; index++) {
+        if (offset + 30 > bytes.length || index === 64) {
+            cut = true;
+            break;
+        }
+        if (u32(bytes, offset) !== 0x04034b50)
+            break;
+        const flags = u16(bytes, offset + 6), method = u16(bytes, offset + 8), size = u32(bytes, offset + 18);
+        const nameStart = offset + 30, nameEnd = nameStart + u16(bytes, offset + 26), dataStart = nameEnd + u16(bytes, offset + 28);
+        if (nameEnd > bytes.length) {
+            cut = true;
+            break;
+        }
+        const name = ascii(bytes.subarray(nameStart, nameEnd));
+        // Only these two are ever read, and never a big one: `ascii` spreads its bytes, and a whole file can hold a large stored entry.
+        const stored = (name === 'mimetype' || name === '[Content_Types].xml') && method === 0 && (flags & 8) === 0 && size <= SNIFF_BYTES && dataStart + size <= bytes.length ? ascii(bytes.subarray(dataStart, dataStart + size)) : undefined;
         if (index === 0 && name === 'mimetype' && stored !== undefined)
             return ZIP_MIMETYPES.has(stored.trim()) ? stored.trim() : undefined;
-        if (name === '[Content_Types].xml') {
-            contentTypes = true;
-            const named = stored === undefined ? undefined : OOXML_MAIN.find(([main]) => stored.includes(`${main}+xml`));
+        if (name === '[Content_Types].xml' && stored !== undefined) {
+            const named = OOXML_MAIN.find(([main]) => stored.includes(`${main}+xml`));
             if (named)
                 return named[2];
         }
-        else if (contentTypes) {
-            const folder = OOXML_MAIN.find(([, prefix]) => name.startsWith(prefix));
-            if (folder)
-                return folder[2];
+        names.push(name);
+        const office = officeTypeOf(names);
+        if (office)
+            return office;
+        if (flags & 8) {
+            cut = true;
+            break;
         }
-        if (flags & 8)
-            return undefined;
         offset = dataStart + size;
+        if (offset >= bytes.length)
+            cut = true;
     }
-    return undefined;
+    const directory = zipDirectoryNames(bytes);
+    if (directory)
+        return officeTypeOf(directory);
+    if (!cut || bytes.length < SNIFF_BYTES)
+        return undefined;
+    return OOXML_MAIN.find(([, prefix]) => names.some(name => name.startsWith(prefix) && name.endsWith('.xml')))?.[2];
 }
 /**
- * The media type a file's leading bytes name, or undefined. Pass up to `SNIFF_BYTES` of them.
+ * The media type a file's leading bytes name, or undefined. Pass at least `SNIFF_BYTES` of them when there are that many; only a zip
+ * looks further, so more bytes (the whole file) let it read its central directory.
  *  - Signatures: PDF, PNG, JPEG, GIF, WebP, HEIC/HEIF and MP4/MOV/M4V (`ftyp` brands), WebM (EBML), and zip-based documents.
  *  - Otherwise `text/plain` when the bytes are valid UTF-8 (a character cut at the end is allowed) with no NUL byte: a weak answer, a
  *    name says better which text it is (`delimitedTextType` for CSV and TSV).
@@ -123,7 +178,7 @@ export function sniffMediaType(head) {
     if (at([0x1a, 0x45, 0xdf, 0xa3]))
         return 'video/webm';
     if (at([0x50, 0x4b, 0x03, 0x04]))
-        return sniffZip(head.subarray(0, SNIFF_BYTES));
+        return sniffZip(head);
     const sample = head.subarray(0, SNIFF_BYTES);
     if (sample.length === 0 || sample.includes(0))
         return undefined;

package/dist/revision-contracts.d.ts

@@ -25,6 +25,11 @@ export interface FileEntry {
 export interface FilePage {
     readonly entries: readonly FileEntry[];
     readonly cursor?: string;
+    /**
+     * Whether the caller may write in the listed folder (add, upload, rename, move or delete there), as the host decides it. Absent: the
+     * host says nothing, and the views offer what the client and its capabilities offer. A view never infers it from roles or config.
+     */
+    readonly writable?: boolean;
 }
 export interface FileListRequest {
     readonly directory?: string;
@@ -81,8 +86,13 @@ export interface WorkspaceCatalog {
     readonly history: (path: string, access: ResourceAccess) => Promise<readonly SavedRevision[]>;
 }
 export declare class RevisionError extends Error {
-    readonly kind: 'denied' | 'unavailable' | 'invalid' | 'aborted';
-    constructor(kind: 'denied' | 'unavailable' | 'invalid' | 'aborted', message: string);
+    readonly kind: 'denied' | 'unavailable' | 'invalid' | 'aborted' | 'missing';
+    readonly status?: number | undefined;
+    /**
+     * `missing`: the addressed folder or file is not there (or not for this caller): HTTP 404. `status`: the HTTP status the host answered,
+     * when it answered one (`connectRevisionProvider` sets it), so a 403 can be told from a 409 binding mismatch, both `denied`.
+     */
+    constructor(kind: 'denied' | 'unavailable' | 'invalid' | 'aborted' | 'missing', message: string, status?: number | undefined);
 }
 /** One authenticated binding for viewers, file browsing and publication. */
 export interface RevisionProvider extends ResourceClient {

package/dist/revision-contracts.js

@@ -1,8 +1,14 @@
 export class RevisionError extends Error {
     kind;
-    constructor(kind, message) {
+    status;
+    /**
+     * `missing`: the addressed folder or file is not there (or not for this caller): HTTP 404. `status`: the HTTP status the host answered,
+     * when it answered one (`connectRevisionProvider` sets it), so a 403 can be told from a 409 binding mismatch, both `denied`.
+     */
+    constructor(kind, message, status) {
         super(message);
         this.kind = kind;
+        this.status = status;
         this.name = 'RevisionError';
     }
 }

package/dist/revision-handler.js

@@ -213,7 +213,7 @@ export function createRevisionHandler(options) {
             return new Response(body, { headers: { 'content-type': 'application/json', 'cache-control': 'no-store' } });
         }
         catch (error) {
-            return refuse(error instanceof RevisionError ? error.kind === 'invalid' ? 400 : error.kind === 'denied' || error.kind === 'aborted' ? 403 : 503 : error instanceof RequestGuardError || error instanceof TypeError ? guardStatus(error) : 503);
+            return refuse(error instanceof RevisionError ? error.kind === 'invalid' ? 400 : error.kind === 'denied' || error.kind === 'aborted' ? 403 : error.kind === 'missing' ? 404 : 503 : error instanceof RequestGuardError || error instanceof TypeError ? guardStatus(error) : 503);
         }
         finally {
             await Promise.allSettled([...operations]);

package/dist/revision-protocol.js

@@ -44,7 +44,9 @@ export function filePage(value) {
     });
     if (new Set(entries.map(entry => entry.path)).size !== entries.length)
         throw new RevisionError('invalid', 'Duplicate file entries');
-    return { entries, ...(typeof data.cursor === 'string' ? { cursor: data.cursor } : {}) };
+    if (data.writable !== undefined && typeof data.writable !== 'boolean')
+        throw new RevisionError('invalid', 'Invalid file page');
+    return { entries, ...(typeof data.cursor === 'string' ? { cursor: data.cursor } : {}), ...(typeof data.writable === 'boolean' ? { writable: data.writable } : {}) };
 }
 export function savedRevisions(value) {
     if (!Array.isArray(value) || value.length > 100_000)

package/dist/revision.js

@@ -22,7 +22,7 @@ export async function connectRevisionProvider(options) {
             }
             if (response.redirected || !response.ok) {
                 void response.body?.cancel().catch(() => { });
-                throw new RevisionError(response.status === 403 || response.status === 409 ? 'denied' : response.status === 400 ? 'invalid' : 'unavailable', 'The selected workspace is unavailable or no longer authorized');
+                throw new RevisionError(response.status === 403 || response.status === 409 ? 'denied' : response.status === 400 ? 'invalid' : response.status === 404 ? 'missing' : 'unavailable', response.status === 404 ? 'Not found' : 'The selected workspace is unavailable or no longer authorized', response.status);
             }
             return await readJsonBody(response, 8_388_608, request.signal);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-files",
-  "version": "0.4.51",
+  "version": "0.4.52",
   "license": "MIT",
   "private": false,
   "type": "module",