rmapi-js 5.0.0 → 6.0.0

package/dist/index.js

@@ -7,7 +7,7 @@
  * {@link RemarkableApi | `RemarkableApi`}.
  *
  * @example
- * A simple fetch
+ * A simple rename
  * ```ts
  * import { register, remarkable } from "rmapi-js";
  *
@@ -15,17 +15,9 @@
  * const token = await register(code)
  * // persist token
  * const api = await remarkable(token);
- * const rootEntries = await api.getEntries();
- * for (const entry of rootEntries) {
- *   const children = await api.getEntries(entry.hash);
- *   for (const { hash, documentId } of children) {
- *     if (documentId.endsWith(".metadata")) {
- *       const meta = api.getMetadata(hash);
- *       // get metadata for entry
- *       console.log(meta);
- *     }
- *   }
- * }
+ * const [first, ...rest] = api.listfiles();
+ * // rename first file
+ * const api.rename(first.hash, "new name");
  * ```
  *
  * @example
@@ -38,173 +30,66 @@
  * await api.create(entry);
  * ```
  *
+ * @remarks
+ *
+ * The cloud api is essentially a collection of entries. Each entry has an id,
+ * which is a uuid4 and a hash, which indicates it's current state, and changes
+ * as the item mutates, where the id is constant. Most mutable operations take
+ * the initial hash so that merge conflicts can be resolved. Each entry has a
+ * number of properties, but a key is the `parent`, which represents its parent
+ * in the file structure. This will be another document id, or one of two
+ * special ids, "" (the empty string) for the root directory, or "trash" for the
+ * trash.
+ *
  * @packageDocumentation
  */
 import { fromByteArray } from "base64-js";
-import stringify from "json-stable-stringify";
+import { boolean, discriminator, elements, enumeration, float64, properties, string, values, } from "jtd-ts";
 import { v4 as uuid4 } from "uuid";
-import { concatBuffers, fromHex, toHex } from "./utils";
-import { validate } from "./validate";
-const SCHEMA_VERSION = "3";
 const AUTH_HOST = "https://webapp-prod.cloud.remarkable.engineering";
-const SYNC_HOST = "https://internal.cloud.remarkable.com";
-const GENERATION_HEADER = "x-goog-generation";
-const GENERATION_RACE_HEADER = "x-goog-if-generation-match";
-const CONTENT_LENGTH_RANGE_HEADER = "x-goog-content-length-range";
-/** tool options */
-/* eslint-disable spellcheck/spell-checker */
-export const builtinTools = [
-    "Ballpoint",
-    "Ballpointv2",
-    "Brush",
-    "Calligraphy",
-    "ClearPage",
-    "EraseSection",
-    "Eraser",
-    "Fineliner",
-    "Finelinerv2",
-    "Highlighter",
-    "Highlighterv2",
-    "Marker",
-    "Markerv2",
-    "Paintbrush",
-    "Paintbrushv2",
-    "Pencilv2",
-    "SharpPencil",
-    "SharpPencilv2",
-    "SolidPen",
-    "ZoomTool",
-];
-/* eslint-enable spellcheck/spell-checker */
-/** font name options */
-/* eslint-disable spellcheck/spell-checker */
-export const builtinFontNames = [
-    "Maison Neue",
-    "EB Garamond",
-    "Noto Sans",
-    "Noto Serif",
-    "Noto Mono",
-    "Noto Sans UI",
-];
-/* eslint-enable spellcheck/spell-checker */
-/** text scale options */
-export const builtinTextScales = {
-    /** the smallest */
-    xs: 0.7,
-    /** small */
-    sm: 0.8,
-    /** medium / default */
-    md: 1.0,
-    /** large */
-    lg: 1.2,
-    /** extra large */
-    xl: 1.5,
-    /** double extra large */
-    xx: 2.0,
-};
-/** margin options */
-export const builtinMargins = {
-    /** small */
-    sm: 50,
-    /** medium */
-    md: 125,
-    /** default for read on remarkable */
-    rr: 180,
-    /** large */
-    lg: 200,
-};
-/** line height options */
-export const builtinLineHeights = {
-    /** default */
-    df: -1,
-    /** normal */
-    md: 100,
-    /** half */
-    lg: 150,
-    /** double */
-    xl: 200,
-};
-const uploadEntrySchema = {
-    properties: {
-        docID: { type: "string" },
-        hash: { type: "string" },
-    },
-};
-const urlResponseSchema = {
-    properties: {
-        relative_path: { type: "string" },
-        url: { type: "string" },
-        expires: { type: "timestamp" },
-        method: { enum: ["POST", "GET", "PUT", "DELETE"] },
-    },
-    optionalProperties: {
-        maxuploadsize_bytes: { type: "float64" },
-    },
-};
+const SYNC_HOST = "https://web.eu.tectonic.remarkable.com";
+const idReg = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}||trash)$/;
+const hashReg = /^[0-9a-f]{64}$/;
+/** simple verification wrapper that allows for bypassing */
+function verification(res, schema, verify) {
+    if (!verify || schema.guard(res)) {
+        return res;
+    }
+    else {
+        throw new Error(`couldn't validate schema: ${JSON.stringify(res)} didn't match schema ${JSON.stringify(schema.schema())}`);
+    }
+}
 const commonProperties = {
-    visibleName: { type: "string" },
+    id: string(),
+    hash: string(),
+    visibleName: string(),
+    lastModified: string(),
+    pinned: boolean(),
 };
 const commonOptionalProperties = {
-    lastModified: { type: "string" },
-    version: { type: "int32" },
-    pinned: { type: "boolean" },
-    synced: { type: "boolean" },
-    modified: { type: "boolean" },
-    deleted: { type: "boolean" },
-    metadatamodified: { type: "boolean" },
-    parent: { type: "string" },
-};
-const metadataSchema = {
-    discriminator: "type",
-    mapping: {
-        CollectionType: {
-            properties: commonProperties,
-            optionalProperties: commonOptionalProperties,
-            additionalProperties: true,
-        },
-        DocumentType: {
-            properties: commonProperties,
-            optionalProperties: {
-                ...commonOptionalProperties,
-                lastOpened: { type: "string" },
-                lastOpenedPage: { type: "int32" },
-                createdTime: { type: "string" },
-            },
-            additionalProperties: true,
-        },
-    },
-};
-const baseMetadataProperties = {
-    id: { type: "string" },
-    hash: { type: "string" },
-};
-const metadataEntrySchema = {
-    discriminator: "type",
-    mapping: {
-        CollectionType: {
-            properties: {
-                ...commonProperties,
-                ...baseMetadataProperties,
-            },
-            optionalProperties: commonOptionalProperties,
-            additionalProperties: true,
-        },
-        DocumentType: {
-            properties: {
-                ...commonProperties,
-                ...baseMetadataProperties,
-                fileType: { enum: ["notebook", "epub", "pdf", ""] },
-            },
-            optionalProperties: {
-                ...commonOptionalProperties,
-                lastOpened: { type: "string" },
-                lastOpenedPage: { type: "int32" },
-                createdTime: { type: "string" },
-            },
-            additionalProperties: true,
-        },
-    },
+    parent: string(),
+    tags: elements(properties({
+        name: string(),
+        timestamp: float64(),
+    })),
 };
+const entry = discriminator("type", {
+    CollectionType: properties(commonProperties, commonOptionalProperties, true),
+    DocumentType: properties({
+        ...commonProperties,
+        lastOpened: string(),
+        fileType: enumeration("epub", "pdf", "notebook"),
+    }, commonOptionalProperties, true),
+});
+const entries = elements(entry);
+const uploadEntry = properties({
+    docID: string(),
+    hash: string(),
+});
+const hashEntry = properties({ hash: string() });
+const hashesEntry = properties({
+    hashes: values(string()),
+});
 /** an error that results from a failed request */
 export class ResponseError extends Error {
     /** the response status number */
@@ -217,15 +102,16 @@ export class ResponseError extends Error {
         this.statusText = statusText;
     }
 }
-/**
- * an error that results from trying yp update the wrong generation.
- *
- * If we try to update the root hash of files, but the generation has changed
- * relative to the one we're updating from, this will fail.
- */
-export class GenerationError extends Error {
-    constructor() {
-        super("Generation preconditions failed. This means the current state is out of date with the cloud and needs to be re-synced.");
+/** an error that results from a failed request */
+export class ValidationError extends Error {
+    /** the response status number */
+    field;
+    /** the response status text */
+    regex;
+    constructor(field, regex, message) {
+        super(message);
+        this.field = field;
+        this.regex = regex;
     }
 }
 /**
@@ -260,67 +146,15 @@ export async function register(code, { deviceDesc = "browser-chrome", uuid = uui
         return await resp.text();
     }
 }
-/** format an entry */
-export function formatEntry({ hash, type, documentId, subfiles, size, }) {
-    return `${hash}:${type}:${documentId}:${subfiles}:${size}\n`;
-}
-/** parse an entry */
-export function parseEntry(line) {
-    const [hash, type, documentId, subfiles, size] = line.split(":");
-    if (hash === undefined ||
-        type === undefined ||
-        documentId === undefined ||
-        subfiles === undefined ||
-        size === undefined) {
-        throw new Error(`entries line didn't contain five fields: '${line}'`);
-    }
-    if (type === "80000000") {
-        return {
-            hash,
-            type,
-            documentId,
-            subfiles: parseInt(subfiles),
-            size: BigInt(size),
-        };
-    }
-    else if (type === "0") {
-        if (subfiles !== "0") {
-            throw new Error(`file type entry had nonzero number of subfiles: ${subfiles}`);
-        }
-        else {
-            return {
-                hash,
-                type,
-                documentId,
-                subfiles: 0,
-                size: BigInt(size),
-            };
-        }
-    }
-    else {
-        throw new Error(`entries line contained invalid type: ${type}`);
-    }
-}
 /** the implementation of that api */
 class Remarkable {
     #userToken;
     #fetch;
-    #subtle;
     #syncHost;
-    // caches
-    #cacheLimitBytes;
-    #cache = new Map();
-    #rootCache = null;
-    constructor(userToken, fetch, subtle, syncHost, cacheLimitBytes, initCache) {
+    constructor(userToken, fetch, syncHost) {
         this.#userToken = userToken;
         this.#fetch = fetch;
-        this.#subtle = subtle;
         this.#syncHost = syncHost;
-        this.#cacheLimitBytes = cacheLimitBytes;
-        // set cache
-        for (const [hash, val] of initCache) {
-            this.#cache.set(hash, Promise.resolve(val));
-        }
     }
     /** make an authorized request to remarkable */
     async #authedFetch(url, { body, method = "POST", headers = {}, }) {
@@ -340,495 +174,117 @@ class Remarkable {
             return resp;
         }
     }
-    /** make a signed request to the cloud */
-    async #signedFetch({ url, method, maxuploadsize_bytes }, body, add_headers = {}) {
-        const headers = maxuploadsize_bytes
-            ? {
-                ...add_headers,
-                [CONTENT_LENGTH_RANGE_HEADER]: `0,${maxuploadsize_bytes}`,
-            }
-            : add_headers;
-        const resp = await this.#fetch(url, {
-            method,
+    /** a generic request to the new files api
+     *
+     * @param meta - remarkable metadata to set, often json formatted or empty
+     * @param method - the http method to use
+     * @param contentType - the http content type to set
+     * @param body - body content, often raw bytes or json
+     * @param hash - the hash of a specific file to target
+     */
+    async #fileRequest({ meta = "", method = "GET", 
+    // eslint-disable-next-line spellcheck/spell-checker
+    contentType = "text/plain;charset=UTF-8", body, hash, } = {}) {
+        const encoder = new TextEncoder();
+        const encMeta = encoder.encode(meta);
+        const suffix = hash === undefined ? "" : `/${hash}`;
+        const resp = await this.#authedFetch(`${this.#syncHost}/doc/v2/files${suffix}`, {
             body,
-            headers,
+            method,
+            headers: {
+                "content-type": contentType,
+                "rm-meta": fromByteArray(encMeta),
+                "rm-source": "WebLibrary",
+            },
         });
-        if (!resp.ok) {
-            const msg = await resp.text();
-            throw new ResponseError(resp.status, resp.statusText, msg);
-        }
-        else {
-            return resp;
-        }
-    }
-    /** get the details for how to make a signed request to remarkable cloud */
-    async #getUrl(relativePath, gen, rootHash) {
-        const key = gen === undefined ? "downloads" : "uploads";
-        // NOTE this is done manually to serialize the bigints appropriately
-        const body = rootHash && gen !== null && gen !== undefined
-            ? `{ "http_method": "PUT", "relative_path": "${relativePath}", "root_schema": "${rootHash}", "generation": ${gen} }`
-            : JSON.stringify({ http_method: "GET", relative_path: relativePath });
-        const resp = await this.#authedFetch(`${this.#syncHost}/sync/v2/signed-urls/${key}`, { body });
         const raw = await resp.text();
-        const res = JSON.parse(raw);
-        validate(urlResponseSchema, res);
-        return res;
-    }
-    /**
-     * get the root hash and the current generation
-     */
-    async getRootHash({ cache = true } = {}) {
-        if (cache) {
-            while (this.#rootCache) {
-                try {
-                    const [hash, gen] = await this.#rootCache;
-                    return [hash, gen];
-                }
-                catch {
-                    // noop
-                }
-            }
-        }
-        const prom = (async () => {
-            try {
-                const signed = await this.#getUrl("root");
-                const resp = await this.#signedFetch(signed);
-                const generation = resp.headers.get(GENERATION_HEADER);
-                if (!generation) {
-                    throw new Error("no generation header in root hash");
-                }
-                else {
-                    return [await resp.text(), BigInt(generation)];
-                }
-            }
-            catch (ex) {
-                this.#rootCache = null;
-                throw ex;
-            }
-        })();
-        this.#rootCache = prom;
-        const [hash, gen] = await prom;
-        return [hash, gen];
-    }
-    /**
-     * write the root hash, incrementing from the current generation
-     */
-    async putRootHash(hash, generation) {
-        const signed = await this.#getUrl("root", generation, hash);
-        let resp;
-        try {
-            resp = await this.#signedFetch(signed, hash, {
-                [GENERATION_RACE_HEADER]: `${generation}`,
-            });
-        }
-        catch (ex) {
-            if (ex instanceof ResponseError && ex.status === 412) {
-                this.#rootCache = null;
-                throw new GenerationError();
-            }
-            else {
-                throw ex;
-            }
-        }
-        const genStr = resp.headers.get(GENERATION_HEADER);
-        if (!genStr) {
-            throw new Error("no generation header in root hash");
-        }
-        const gen = BigInt(genStr);
-        this.#rootCache = Promise.resolve([hash, gen]);
-        return gen;
-    }
-    /**
-     * get content associated with hash
-     */
-    async #getHash(hash) {
-        let cached = this.#cache.get(hash);
-        while (cached) {
-            try {
-                const val = await cached;
-                if (val) {
-                    return val;
-                }
-                else {
-                    cached = undefined; // break
-                }
-            }
-            catch {
-                // try again if promise rejected
-                cached = this.#cache.get(hash);
-            }
-        }
-        const prom = (async () => {
-            const signed = await this.#getUrl(hash);
-            const resp = await this.#signedFetch(signed);
-            return await resp.arrayBuffer();
-        })();
-        // set cache with appropriate promise that cleans up on rejection
-        this.#cache.set(hash, prom.then((buff) => (buff.byteLength < this.#cacheLimitBytes ? buff : null), (ex) => {
-            this.#cache.delete(hash);
-            throw ex;
-        }));
-        return await prom;
-    }
-    /**
-     * get text content associated with hash
-     */
-    async getBuffer(hash) {
-        const buff = await this.#getHash(hash);
-        // copy if it is long enough to be cached to preven mutations
-        return buff.byteLength < this.#cacheLimitBytes ? buff.slice(0) : buff;
+        return JSON.parse(raw);
     }
-    /**
-     * get text content associated with hash
-     */
-    async getText(hash) {
-        const buff = await this.#getHash(hash);
-        const decoder = new TextDecoder();
-        return decoder.decode(buff);
+    /** list all files */
+    async listFiles({ verify = true } = {}) {
+        const res = await this.#fileRequest();
+        return verification(res, entries, verify);
     }
-    /**
-     * get json content associated with hash
-     */
-    async getJson(hash) {
-        const str = await this.getText(hash);
-        return JSON.parse(str);
-    }
-    /**
-     * get metadata from hash
-     *
-     * Call with `verify: false` to disable checking the response.
-     */
-    async getMetadata(hash, { verify = true } = {}) {
-        const raw = await this.getJson(hash);
-        validate(metadataSchema, raw, verify);
-        return raw;
-    }
-    /**
-     * get entries from a collection hash
-     */
-    async getEntries(hash) {
-        if (hash === undefined) {
-            const [newHash] = await this.getRootHash({ cache: true });
-            hash = newHash;
-        }
-        const raw = await this.getText(hash);
-        // slice for trailing new line
-        const [schema, ...lines] = raw.slice(0, -1).split("\n");
-        if (schema !== SCHEMA_VERSION) {
-            throw new Error(`got unexpected schema version: ${schema}`);
-        }
-        return lines.map(parseEntry);
-    }
-    /** upload data to hash */
-    async #putHash(hash, body) {
-        // try cached version
-        const cached = this.#cache.get(hash);
-        if (cached) {
-            try {
-                await cached;
-                return;
-            }
-            catch {
-                // noop
-            }
+    /** upload a file */
+    async #uploadFile(parent, visibleName, buffer, contentType, verify) {
+        if (verify && !idReg.test(parent)) {
+            throw new ValidationError(parent, idReg, "parent must be a valid document id");
         }
-        // if missing or rejected then put for real
-        const prom = (async () => {
-            try {
-                const signed = await this.#getUrl(hash, null);
-                await this.#signedFetch(signed, body);
-                return body.byteLength < this.#cacheLimitBytes ? body : null;
-            }
-            catch (ex) {
-                this.#cache.delete(hash);
-                throw ex;
-            }
-        })();
-        this.#cache.set(hash, prom);
-        await prom;
-    }
-    /** put a reference to a set of entries into the cloud */
-    async putEntries(documentId, entries) {
-        // hash of a collection is the hash of all hashes in documentId order
-        const enc = new TextEncoder();
-        entries.sort((a, b) => a.documentId.localeCompare(b.documentId));
-        const hashes = concatBuffers(entries.map((ent) => fromHex(ent.hash)));
-        const digest = await this.#subtle.digest("SHA-256", hashes);
-        const hash = toHex(new Uint8Array(digest));
-        const entryContents = entries.map(formatEntry).join("");
-        const contents = `${SCHEMA_VERSION}\n${entryContents}`;
-        const buffer = enc.encode(contents).buffer;
-        await this.#putHash(hash, buffer);
-        return {
-            hash,
-            type: "80000000",
-            documentId,
-            subfiles: entries.length,
-            size: 0n,
-        };
-    }
-    /** put a raw buffer in the cloud */
-    async putBuffer(documentId, buffer) {
-        const digest = await this.#subtle.digest("SHA-256", buffer);
-        const hash = toHex(new Uint8Array(digest));
-        await this.#putHash(hash, buffer);
-        return {
-            hash,
-            type: "0",
-            documentId,
-            subfiles: 0,
-            size: BigInt(buffer.byteLength),
-        };
-    }
-    /** put text in the cloud */
-    async putText(documentId, contents) {
-        const enc = new TextEncoder();
-        const encoded = enc.encode(contents).buffer;
-        return await this.putBuffer(documentId, encoded);
-    }
-    /** put json in the cloud */
-    async putJson(documentId, contents) {
-        return await this.putText(documentId, stringify(contents));
-    }
-    /** put metadata into the cloud */
-    async putMetadata(documentId, metadata) {
-        return await this.putJson(`${documentId}.metadata`, metadata);
+        const res = await this.#fileRequest({
+            meta: JSON.stringify({ parent, file_name: visibleName }),
+            method: "POST",
+            contentType,
+            body: buffer,
+        });
+        return verification(res, uploadEntry, verify);
     }
-    /** put a new collection (folder) */
-    async putCollection(visibleName, parent = "") {
-        const documentId = uuid4();
-        const lastModified = `${new Date().valueOf()}`;
-        const entryPromises = [];
-        // upload metadata
-        const metadata = {
-            type: "CollectionType",
-            visibleName,
-            version: 0,
-            parent,
-            synced: true,
-            lastModified,
-        };
-        entryPromises.push(this.putMetadata(documentId, metadata));
-        entryPromises.push(this.putText(`${documentId}.content`, "{}"));
-        const entries = await Promise.all(entryPromises);
-        return await this.putEntries(documentId, entries);
-    }
-    /** upload a content file */
-    async #putContent(visibleName, buffer, fileType, parent, content) {
-        /* istanbul ignore if */
-        if (content.fileType !== fileType) {
-            throw new Error(`internal error: fileTypes don't match: ${fileType}, ${content.fileType}`);
-        }
-        const documentId = uuid4();
-        const lastModified = `${new Date().valueOf()}`;
-        const entryPromises = [];
-        // upload main document
-        entryPromises.push(this.putBuffer(`${documentId}.${fileType}`, buffer));
-        // upload metadata
-        const metadata = {
-            type: "DocumentType",
-            visibleName,
-            version: 0,
-            parent,
-            synced: true,
-            lastModified,
-        };
-        entryPromises.push(this.putMetadata(documentId, metadata));
-        entryPromises.push(this.putText(`${documentId}.content`, JSON.stringify(content)));
-        // NOTE we technically get the entries a bit earlier, so could upload this
-        // before all contents are uploaded, but this also saves us from uploading
-        // the contents entry before all have uploaded successfully
-        const entries = await Promise.all(entryPromises);
-        return await this.putEntries(documentId, entries);
+    /** create a folder */
+    async createFolder(visibleName, { parent = "", verify = true } = {}) {
+        return await this.#uploadFile(parent, visibleName, new ArrayBuffer(0), "folder", verify);
     }
     /** upload an epub */
-    async putEpub(visibleName, buffer, { parent = "", margins = 125, orientation, textAlignment, textScale = 1, lineHeight = -1, fontName = "", cover = "visited", lastTool, } = {}) {
-        // upload content file
-        const content = {
-            dummyDocument: false,
-            extraMetadata: {
-                LastTool: lastTool,
-            },
-            fileType: "epub",
-            pageCount: 0,
-            lastOpenedPage: 0,
-            lineHeight: typeof lineHeight === "string"
-                ? builtinLineHeights[lineHeight]
-                : lineHeight,
-            margins: typeof margins === "string" ? builtinMargins[margins] : margins,
-            textScale: typeof textScale === "string"
-                ? builtinTextScales[textScale]
-                : textScale,
-            pages: [],
-            coverPageNumber: cover === "first" ? 0 : -1,
-            formatVersion: 1,
-            orientation,
-            textAlignment,
-            fontName,
-        };
-        return await this.#putContent(visibleName, buffer, "epub", parent, content);
+    async uploadEpub(visibleName, buffer, { parent = "", verify = true } = {}) {
+        return await this.#uploadFile(parent, visibleName, buffer, "application/epub+zip", verify);
     }
     /** upload a pdf */
-    async putPdf(visibleName, buffer, { parent = "", orientation, cover = "first", lastTool } = {}) {
-        // upload content file
-        const content = {
-            dummyDocument: false,
-            extraMetadata: {
-                LastTool: lastTool,
-            },
-            fileType: "pdf",
-            pageCount: 0,
-            lastOpenedPage: 0,
-            lineHeight: -1,
-            margins: 125,
-            textScale: 1,
-            pages: [],
-            coverPageNumber: cover === "first" ? 0 : -1,
-            formatVersion: 1,
-            orientation,
-        };
-        return await this.#putContent(visibleName, buffer, "pdf", parent, content);
-    }
-    /** send sync complete request */
-    async syncComplete(generation) {
-        // NOTE this is done manually to properly serialize the bigint
-        const body = `{ "generation": ${generation} }`;
-        await this.#authedFetch(`${this.#syncHost}/sync/v2/sync-complete`, {
-            body,
-        });
+    async uploadPdf(visibleName, buffer, { parent = "", verify = true } = {}) {
+        return await this.#uploadFile(parent, visibleName, buffer, "application/pdf", verify);
     }
-    /** try to sync, always succeed */
-    async #tryPutRootEntries(gen, entries, sync) {
-        const { hash } = await this.putEntries("", entries);
-        const nextGen = await this.putRootHash(hash, gen);
-        if (sync) {
-            try {
-                await this.syncComplete(nextGen);
-                return true;
-            }
-            catch {
-                return false;
-            }
+    async #modify(hash, properties, verify) {
+        if (verify && !hashReg.test(hash)) {
+            throw new ValidationError(hash, hashReg, "hash to modify was not a valid hash");
         }
-        else {
-            return false;
-        }
-    }
-    /** high level api to create an entry */
-    async create(entry, { cache = true, sync = true } = {}) {
-        const [root, gen] = await this.getRootHash({ cache });
-        const rootEntries = await this.getEntries(root);
-        rootEntries.push(entry);
-        return await this.#tryPutRootEntries(gen, rootEntries, sync);
+        // this does not allow setting pinned, although I don't know why
+        const res = await this.#fileRequest({
+            hash,
+            body: JSON.stringify(properties),
+            method: "PATCH",
+        });
+        return verification(res, hashEntry, verify);
     }
-    /** high level api to move a document / collection */
-    async move(documentId, dest, { cache = true, sync = true } = {}) {
-        const [root, gen] = await this.getRootHash({ cache });
-        const rootEntries = await this.getEntries(root);
-        // check if destination is a collection
-        if (!dest || dest === "trash") {
-            // fine
+    /** move an entry */
+    async move(hash, parent, { verify = true } = {}) {
+        if (verify && !idReg.test(parent)) {
+            throw new ValidationError(parent, idReg, "parent must be a valid document id");
         }
-        else {
-            // TODO some of these could be done in parallel
-            const entry = rootEntries.find((ent) => ent.documentId === dest);
-            if (!entry) {
-                throw new Error(`destination id not found: ${dest}`);
-            }
-            else if (entry.type !== "80000000") {
-                throw new Error(`destination id was a raw file: ${dest}`);
-            }
-            const ents = await this.getEntries(entry.hash);
-            const [meta] = ents.filter((ent) => ent.documentId === `${dest}.metadata`);
-            if (!meta) {
-                throw new Error(`destination id didn't have metadata: ${dest}`);
+        return await this.#modify(hash, { parent }, verify);
+    }
+    /** delete an entry */
+    async delete(hash, opts = {}) {
+        return await this.move(hash, "trash", opts);
+    }
+    /** rename an entry */
+    async rename(hash, visibleName, { verify = true } = {}) {
+        return await this.#modify(hash, { file_name: visibleName }, verify);
+    }
+    /** bulk modify hashes */
+    async #bulkModify(hashes, properties, verify) {
+        if (verify) {
+            const invalidHashes = hashes.filter((hash) => !hashReg.test(hash));
+            if (invalidHashes.length) {
+                throw new ValidationError(hashes.join(", "), hashReg, "hashes to modify were not a valid hashes");
             }
-            const metadata = await this.getMetadata(meta.hash);
-            if (metadata.type !== "CollectionType") {
-                throw new Error(`destination id wasn't a collection: ${dest}`);
-            }
-        }
-        // get entry to move from root
-        const ind = rootEntries.findIndex((ent) => ent.documentId === documentId);
-        if (ind === -1) {
-            throw new Error(`document not found: ${documentId}`);
-        }
-        const [oldEntry] = rootEntries.splice(ind, 1);
-        if (oldEntry.type !== "80000000") {
-            throw new Error(`document was a raw file: ${documentId}`);
         }
-        // get metadata from entry
-        const docEnts = await this.getEntries(oldEntry.hash);
-        const metaInd = docEnts.findIndex((ent) => ent.documentId === `${documentId}.metadata`);
-        if (metaInd === -1) {
-            throw new Error(`document didn't have metadata: ${documentId}`);
-        }
-        const [metaEnt] = docEnts.splice(metaInd, 1);
-        const metadata = await this.getMetadata(metaEnt.hash);
-        // update metadata
-        metadata.parent = dest;
-        const newMetaEnt = await this.putMetadata(documentId, metadata);
-        docEnts.push(newMetaEnt);
-        // update root entries
-        const newEntry = await this.putEntries(documentId, docEnts);
-        rootEntries.push(newEntry);
-        return await this.#tryPutRootEntries(gen, rootEntries, sync);
-    }
-    /** get entries and metadata for all files */
-    async getEntriesMetadata({ verify = true } = {}) {
-        const resp = await this.#authedFetch(`${this.#syncHost}/doc/v2/files`, {
-            method: "GET",
-            headers: {
-                "rm-source": "RoR-Browser",
-            },
+        // this does not allow setting pinned, although I don't know why
+        const res = await this.#fileRequest({
+            body: JSON.stringify({
+                updates: properties,
+                hashes,
+            }),
+            method: "PATCH",
         });
-        const raw = await resp.text();
-        const res = JSON.parse(raw);
-        const schema = {
-            elements: metadataEntrySchema,
-        };
-        validate(schema, res, verify);
-        return res;
+        return verification(res, hashesEntry, verify);
     }
-    /** upload a file */
-    async #uploadFile(visibleName, buffer, contentType, verify) {
-        const encoder = new TextEncoder();
-        const meta = encoder.encode(JSON.stringify({ file_name: visibleName }));
-        const resp = await this.#authedFetch(`${this.#syncHost}/doc/v2/files`, {
-            body: buffer,
-            headers: {
-                "content-type": contentType,
-                "rm-meta": fromByteArray(meta),
-                "rm-source": "RoR-Browser",
-            },
-        });
-        const raw = await resp.text();
-        const res = JSON.parse(raw);
-        validate(uploadEntrySchema, res, verify);
-        return res;
-    }
-    /** upload an epub */
-    async uploadEpub(visibleName, buffer, { verify = true } = {}) {
-        return await this.#uploadFile(visibleName, buffer, "application/epub+zip", verify);
-    }
-    /** upload a pdf */
-    async uploadPdf(visibleName, buffer, { verify = true } = {}) {
-        // TODO why doesn't this work
-        return await this.#uploadFile(visibleName, buffer, "application/pdf", verify);
-    }
-    async getCache() {
-        const promises = [];
-        for (const [hash, prom] of this.#cache) {
-            promises.push(prom.then((val) => [hash, val], () => [hash, null]));
+    /** move many hashes */
+    async bulkMove(hashes, parent, { verify = true } = {}) {
+        if (verify && !idReg.test(parent)) {
+            throw new ValidationError(parent, idReg, "parent must be a valid document id");
         }
-        const entries = await Promise.all(promises);
-        const cache = new Map();
-        for (const [hash, val] of entries) {
-            if (val) {
-                cache.set(hash, val);
-            }
-        }
-        return cache;
+        return await this.#bulkModify(hashes, { parent }, verify);
+    }
+    /** delete many hashes */
+    async bulkDelete(hashes, opts = {}) {
+        return await this.bulkMove(hashes, "trash", opts);
     }
 }
 /**
@@ -841,10 +297,7 @@ class Remarkable {
  *    registered. Create one with {@link register}.
  * @returns an api instance
  */
-export async function remarkable(deviceToken, { fetch = globalThis.fetch, subtle = globalThis.crypto?.subtle, authHost = AUTH_HOST, syncHost = SYNC_HOST, cacheLimitBytes = 1048576, initCache = [], } = {}) {
-    if (!subtle) {
-        throw new Error("subtle was missing, try specifying it manually");
-    }
+export async function remarkable(deviceToken, { fetch = globalThis.fetch, authHost = AUTH_HOST, syncHost = SYNC_HOST, } = {}) {
     const resp = await fetch(`${authHost}/token/json/2/user/new`, {
         method: "POST",
         headers: {
@@ -855,5 +308,5 @@ export async function remarkable(deviceToken, { fetch = globalThis.fetch, subtle
         throw new Error(`couldn't fetch auth token: ${resp.statusText}`);
     }
     const userToken = await resp.text();
-    return new Remarkable(userToken, fetch, subtle, syncHost, cacheLimitBytes, initCache);
+    return new Remarkable(userToken, fetch, syncHost);
 }