rmapi-js 8.5.0 → 9.0.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { type BackgroundFilter, type CollectionContent, type Content, type DocumentContent, type Metadata, type Orientation, type RawRemarkableApi, type SimpleEntry, type Tag, type TemplateContent, type TextAlignment, type ZoomMode } from "./raw";
 export { HashNotFoundError, ValidationError } from "./error";
-export type { BackgroundFilter, CollectionContent, Content, CPageNumberValue, CPagePage, CPageStringValue, CPages, CPageUUID, DocumentContent, DocumentMetadata, FileType, KeyboardMetadata, Metadata, Orientation, PageTag, RawEntry, RawFileEntry, RawListEntry, RawRemarkableApi, SimpleEntry, Tag, TemplateContent, TextAlignment, UploadMimeType, ZoomMode, } from "./raw";
+export type { BackgroundFilter, CollectionContent, Content, CPageNumberValue, CPagePage, CPageStringValue, CPages, CPageUUID, DocumentContent, DocumentMetadata, Entries, FileType, KeyboardMetadata, Metadata, Orientation, PageTag, RawEntry, RawRemarkableApi, SchemaVersion, SimpleEntry, Tag, TemplateContent, TextAlignment, UploadMimeType, ZoomMode, } from "./raw";
 /** common properties shared by collections and documents */
 export interface EntryCommon {
     /** the document id, a uuid4 */
@@ -226,7 +226,7 @@ export interface RemarkableApi {
      * @remarks
      * If this fails validation and you still want to get the content, you can use
      * the low-level api to get the raw text of the `.content` file in the
-     * `RawListEntry` for this hash.
+     * `RawEntry` for this hash.
      *
      * @param hash - the hash of the item to get content for
      * @returns the content
@@ -241,7 +241,7 @@ export interface RemarkableApi {
      * @remarks
      * If this fails validation and you still want to get the content, you can use
      * the low-level api to get the raw text of the `.metadata` file in the
-     * `RawListEntry` for this hash.
+     * `RawEntry` for this hash.
      *
      * @param hash - the hash of the item to get metadata for
      * @returns the metadata

package/dist/index.js

@@ -144,7 +144,9 @@ class Remarkable {
     }
     async #putRootHash(hash, generation) {
         try {
-            this.#lastHashGen = await this.raw.putRootHash(hash, generation);
+            const [rootHash, gen] = await this.raw.putRootHash(hash, generation);
+            const [, , schemaVersion] = this.#lastHashGen; // guaranteed to be set
+            this.#lastHashGen = [rootHash, gen, schemaVersion];
         }
         catch (ex) {
             // if we hit a generation error, invalidate our cached generation
@@ -178,7 +180,7 @@ class Remarkable {
         }
     }
     async #convertEntry({ hash, id }) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const metaEnt = entries.find((ent) => ent.id.endsWith(".metadata"));
         const contentEnt = entries.find((ent) => ent.id.endsWith(".content"));
         if (metaEnt === undefined) {
@@ -238,11 +240,11 @@ class Remarkable {
     }
     async listIds(refresh = false) {
         const [hash] = await this.#getRootHash(refresh);
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         return entries.map(({ id, hash }) => ({ id, hash }));
     }
     async getContent(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const [cont] = entries.filter((e) => e.id.endsWith(".content"));
         if (cont === undefined) {
             throw new Error(`couldn't find contents for hash ${hash}`);
@@ -252,7 +254,7 @@ class Remarkable {
         }
     }
     async getMetadata(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const [meta] = entries.filter((e) => e.id.endsWith(".metadata"));
         if (meta === undefined) {
             throw new Error(`couldn't find metadata for hash ${hash}`);
@@ -262,7 +264,7 @@ class Remarkable {
         }
     }
     async getPdf(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const [pdf] = entries.filter((e) => e.id.endsWith(".pdf"));
         if (pdf === undefined) {
             throw new Error(`couldn't find pdf for hash ${hash}`);
@@ -272,7 +274,7 @@ class Remarkable {
         }
     }
     async getEpub(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const [epub] = entries.filter((e) => e.id.endsWith(".epub"));
         if (epub === undefined) {
             throw new Error(`couldn't find epub for hash ${hash}`);
@@ -282,7 +284,7 @@ class Remarkable {
         }
     }
     async getDocument(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const zip = new JSZip();
         for (const entry of entries) {
             // TODO if this is .metadata we might want to assert type === "DocumentType"
@@ -331,7 +333,7 @@ class Remarkable {
             sizeInBytes: buffer.length.toFixed(),
         };
         // upload raw files, and get root hash
-        const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [pagedataEntry, uploadPagedata], [fileEntry, uploadFile], [rootHash, generation],] = await Promise.all([
+        const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [pagedataEntry, uploadPagedata], [fileEntry, uploadFile], [rootHash, generation, schemaVersion],] = await Promise.all([
             this.raw.putContent(`${id}.content`, content),
             this.raw.putMetadata(`${id}.metadata`, metadata),
             // eslint-disable-next-line spellcheck/spell-checker
@@ -340,18 +342,13 @@ class Remarkable {
             this.#getRootHash(refresh),
         ]);
         // now fetch root entries and upload this file entry
-        const [[collectionEntry, uploadCollection], rootEntries] = await Promise.all([
-            this.raw.putEntries(id, [
-                contentEntry,
-                metadataEntry,
-                pagedataEntry,
-                fileEntry,
-            ]),
+        const [[collectionEntry, uploadCollection], { entries: rootEntries }] = await Promise.all([
+            this.raw.putEntries(id, [contentEntry, metadataEntry, pagedataEntry, fileEntry], schemaVersion),
             this.raw.getEntries(rootHash),
         ]);
         // now upload a new root entry
         rootEntries.push(collectionEntry);
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", rootEntries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", rootEntries, schemaVersion);
         // before updating the root hash, first upload everything
         await Promise.all([
             uploadContent,
@@ -393,19 +390,19 @@ class Remarkable {
             visibleName,
         };
         // upload folder contents
-        const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [rootHash, generation],] = await Promise.all([
+        const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [rootHash, generation, schemaVersion],] = await Promise.all([
             this.raw.putContent(`${id}.content`, content),
             this.raw.putMetadata(`${id}.metadata`, metadata),
             this.#getRootHash(refresh),
         ]);
         // now fetch root entries and upload this file entry
-        const [[collectionEntry, uploadCollection], rootEntries] = await Promise.all([
-            this.raw.putEntries(id, [contentEntry, metadataEntry]),
+        const [[collectionEntry, uploadCollection], { entries: rootEntries }] = await Promise.all([
+            this.raw.putEntries(id, [contentEntry, metadataEntry], schemaVersion),
             this.raw.getEntries(rootHash),
         ]);
         // now upload a new root entry
         rootEntries.push(collectionEntry);
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", rootEntries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", rootEntries, schemaVersion);
         // before updating the root hash, first upload everything
         await Promise.all([
             uploadContent,
@@ -430,8 +427,8 @@ class Remarkable {
         return await this.raw.uploadFile(visibleName, new Uint8Array(0), "folder");
     }
     /** edit just a content entry */
-    async #editContentRaw(id, hash, update) {
-        const entries = await this.raw.getEntries(hash);
+    async #editContentRaw(id, hash, update, schemaVersion) {
+        const { entries } = await this.raw.getEntries(hash);
         const contInd = entries.findIndex((ent) => ent.id.endsWith(".content"));
         const contEntry = entries[contInd];
         if (contEntry === undefined) {
@@ -441,28 +438,28 @@ class Remarkable {
         Object.assign(cont, update);
         const [newContEntry, uploadCont] = await this.raw.putContent(contEntry.id, cont);
         entries[contInd] = newContEntry;
-        const [result, uploadEntries] = await this.raw.putEntries(id, entries);
+        const [result, uploadEntries] = await this.raw.putEntries(id, entries, schemaVersion);
         const upload = Promise.all([uploadCont, uploadEntries]);
         return [result, upload];
     }
     /** fully sync a content edit */
     async #editContent(hash, update, expectedType, refresh) {
-        const [rootHash, generation] = await this.#getRootHash(refresh);
-        const entries = await this.raw.getEntries(rootHash);
+        const [rootHash, generation, schemaVersion] = await this.#getRootHash(refresh);
+        const { entries } = await this.raw.getEntries(rootHash);
         const hashInd = entries.findIndex((ent) => ent.hash === hash);
         const hashEnt = entries[hashInd];
         if (hashEnt === undefined) {
             throw new HashNotFoundError(hash);
         }
         const [[newEnt, uploadEnt], meta] = await Promise.all([
-            this.#editContentRaw(hashEnt.id, hash, update),
+            this.#editContentRaw(hashEnt.id, hash, update, schemaVersion),
             this.getMetadata(hash),
         ]);
         if (meta.type !== expectedType) {
             throw new Error(`expected type ${expectedType} but got ${meta.type} for hash ${hash}`);
         }
         entries[hashInd] = newEnt;
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", entries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", entries, schemaVersion);
         await Promise.all([uploadEnt, uploadRoot]);
         await this.#putRootHash(rootEntry.hash, generation);
         return { hash: newEnt.hash };
@@ -479,8 +476,8 @@ class Remarkable {
     async updateTemplate(hash, content, refresh = false) {
         return await this.#editContent(hash, content, "TemplateType", refresh);
     }
-    async #editMetaRaw(id, hash, update) {
-        const entries = await this.raw.getEntries(hash);
+    async #editMetaRaw(id, hash, update, schemaVersion) {
+        const { entries } = await this.raw.getEntries(hash);
         const metaInd = entries.findIndex((ent) => ent.id.endsWith(".metadata"));
         const metaEntry = entries[metaInd];
         if (metaEntry === undefined) {
@@ -490,21 +487,21 @@ class Remarkable {
         Object.assign(meta, update);
         const [newMetaEntry, uploadMeta] = await this.raw.putMetadata(metaEntry.id, meta);
         entries[metaInd] = newMetaEntry;
-        const [result, uploadEntries] = await this.raw.putEntries(id, entries);
+        const [result, uploadEntries] = await this.raw.putEntries(id, entries, schemaVersion);
         const upload = Promise.all([uploadMeta, uploadEntries]);
         return [result, upload];
     }
     async #editMeta(hash, update, refresh = false) {
-        const [rootHash, generation] = await this.#getRootHash(refresh);
-        const entries = await this.raw.getEntries(rootHash);
+        const [rootHash, generation, schemaVersion] = await this.#getRootHash(refresh);
+        const { entries } = await this.raw.getEntries(rootHash);
         const hashInd = entries.findIndex((ent) => ent.hash === hash);
         const hashEnt = entries[hashInd];
         if (hashEnt === undefined) {
             throw new HashNotFoundError(hash);
         }
-        const [newEnt, uploadEnt] = await this.#editMetaRaw(hashEnt.id, hash, update);
+        const [newEnt, uploadEnt] = await this.#editMetaRaw(hashEnt.id, hash, update, schemaVersion);
         entries[hashInd] = newEnt;
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", entries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", entries, schemaVersion);
         await Promise.all([uploadEnt, uploadRoot]);
         await this.#putRootHash(rootEntry.hash, generation);
         return { hash: newEnt.hash };
@@ -533,8 +530,8 @@ class Remarkable {
         if (!idReg.test(parent)) {
             throw new ValidationError(parent, idReg, "parent must be a valid document id");
         }
-        const [rootHash, generation] = await this.#getRootHash(refresh);
-        const entries = await this.raw.getEntries(rootHash);
+        const [rootHash, generation, schemaVersion] = await this.#getRootHash(refresh);
+        const { entries } = await this.raw.getEntries(rootHash);
         const hashSet = new Set(hashes);
         const toUpdate = [];
         const newEntries = [];
@@ -542,7 +539,7 @@ class Remarkable {
             const part = hashSet.has(entry.hash) ? toUpdate : newEntries;
             part.push(entry);
         }
-        const resolved = await Promise.all(toUpdate.map(({ id, hash }) => this.#editMetaRaw(id, hash, { parent })));
+        const resolved = await Promise.all(toUpdate.map(({ id, hash }) => this.#editMetaRaw(id, hash, { parent }, schemaVersion)));
         const uploads = [];
         const result = {};
         for (const [i, [newEnt, upload]] of resolved.entries()) {
@@ -550,7 +547,7 @@ class Remarkable {
             uploads.push(upload);
             result[toUpdate[i].hash] = newEnt.hash;
         }
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", newEntries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", newEntries, schemaVersion);
         await Promise.all([Promise.all(uploads), uploadRoot]);
         await this.#putRootHash(rootEntry.hash, generation);
         return { hashes: result };
@@ -571,7 +568,8 @@ class Remarkable {
         // should only go one step) to track all hashes encountered
         // NOTE that we could increase the cache in this process, or it's possible
         // for other calls to increase the cache with misc values.
-        let entries = [await this.raw.getEntries(rootHash)];
+        const base = await this.raw.getEntries(rootHash);
+        let entries = [base.entries];
         let nextEntries = [];
         while (entries.length) {
             for (const entryList of entries) {
@@ -582,7 +580,8 @@ class Remarkable {
                     }
                 }
             }
-            entries = await Promise.all(nextEntries);
+            const resolved = await Promise.all(nextEntries);
+            entries = resolved.map((ent) => ent.entries);
             nextEntries = [];
         }
         for (const key of toDelete) {

package/dist/raw.d.ts

@@ -1,7 +1,10 @@
+import "core-js/proposals/array-buffer-base64";
 /** request types */
 export type RequestMethod = "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
 /** the supported upload mime types */
 export type UploadMimeType = "application/pdf" | "application/epub+zip" | "folder";
+/** the schema version */
+export type SchemaVersion = 3 | 4;
 /** an simple entry without any extra information */
 export interface SimpleEntry {
     /** the document id */
@@ -17,9 +20,9 @@ export interface SimpleEntry {
  * files, the high level entry will have the same hash and id as the low-level
  * entry for that collection.
  */
-export interface RawListEntry {
-    /** collection type (80000000) */
-    type: 80000000;
+export interface RawEntry {
+    /** 80000000 for schema 3 collection type or 0 for schema 4 or schema 3 files or */
+    type: 80000000 | 0;
     /** the hash of the collection this points to */
     hash: string;
     /** the unique id of the collection */
@@ -29,23 +32,21 @@ export interface RawListEntry {
     /** the total size of everything in the collection */
     size: number;
 }
-/** the low-level entry for a single file */
-export interface RawFileEntry {
-    /** file type (0) */
-    type: 0;
-    /** the hash of the file this points to */
-    hash: string;
-    /** the unique id of the file */
-    id: string;
-    /** the number of subfiles, always zero */
-    subfiles: 0;
-    /** the size of the file in bytes */
-    size: number;
-}
-/** a low-level stored entry */
-export type RawEntry = RawListEntry | RawFileEntry;
 /** the type of files reMarkable supports */
 export type FileType = "epub" | "pdf" | "notebook";
+/**
+ * a parsed entries file
+ *
+ * id and size are defined for schema 4 but not for 3
+ */
+export interface Entries {
+    /** the raw entries in the file */
+    entries: RawEntry[];
+    /** the id of this entry, only specified for schema 4 */
+    id?: string;
+    /** the recursive size of this entry, only specified for schema 4 */
+    size?: number;
+}
 /** a tag for an entry */
 export interface Tag {
     /** the name of the tag */
@@ -426,7 +427,7 @@ export interface RawRemarkableApi {
      *
      * @returns the root hash and the current generation
      */
-    getRootHash(): Promise<[string, number]>;
+    getRootHash(): Promise<[string, number, SchemaVersion]>;
     /**
      * get the raw binary data associated with a hash
      *
@@ -453,7 +454,7 @@ export interface RawRemarkableApi {
      * @param hash - the hash to get entries for
      * @returns the entries
      */
-    getEntries(hash: string): Promise<RawEntry[]>;
+    getEntries(hash: string): Promise<Entries>;
     /**
      * get the parsed and validated `Content` of a content hash
      *
@@ -508,13 +509,13 @@ export interface RawRemarkableApi {
      * @param bytes - the bytes to upload
      * @returns the new entry and a promise to finish the upload
      */
-    putFile(id: string, bytes: Uint8Array): Promise<[RawFileEntry, Promise<void>]>;
+    putFile(id: string, bytes: Uint8Array): Promise<[RawEntry, Promise<void>]>;
     /** the same as {@link putFile | `putFile`} but with caching for text */
-    putText(id: string, content: string): Promise<[RawFileEntry, Promise<void>]>;
+    putText(id: string, content: string): Promise<[RawEntry, Promise<void>]>;
     /** the same as {@link putText | `putText`} but with extra validation for Content */
-    putContent(id: string, content: Content): Promise<[RawFileEntry, Promise<void>]>;
+    putContent(id: string, content: Content): Promise<[RawEntry, Promise<void>]>;
     /** the same as {@link putText | `putText`} but with extra validation for Metadata */
-    putMetadata(id: string, metadata: Metadata): Promise<[RawFileEntry, Promise<void>]>;
+    putMetadata(id: string, metadata: Metadata): Promise<[RawEntry, Promise<void>]>;
     /**
      * put a set of entries to make an entry list file
      *
@@ -530,7 +531,7 @@ export interface RawRemarkableApi {
      *
      * @returns the new list entry and a promise to finish the upload
      */
-    putEntries(id: string, entries: RawEntry[]): Promise<[RawListEntry, Promise<void>]>;
+    putEntries(id: string, entries: RawEntry[], schemaVersion: SchemaVersion): Promise<[RawEntry, Promise<void>]>;
     /**
      * upload a file to the reMarkable cloud using the simple api
      *
@@ -562,18 +563,18 @@ export declare class RawRemarkable implements RawRemarkableApi {
     #private;
     constructor(authedFetch: AuthedFetch, cache: Map<string, string | null>, rawHost: string, uploadHost: string);
     /** make an authorized request to remarkable */
-    getRootHash(): Promise<[string, number]>;
+    getRootHash(): Promise<[string, number, SchemaVersion]>;
     getHash(hash: string): Promise<Uint8Array>;
     getText(hash: string): Promise<string>;
-    getEntries(hash: string): Promise<RawEntry[]>;
+    getEntries(hash: string): Promise<Entries>;
     getContent(hash: string): Promise<Content>;
     getMetadata(hash: string): Promise<Metadata>;
     putRootHash(hash: string, generation: number, broadcast?: boolean): Promise<[string, number]>;
-    putFile(id: string, bytes: Uint8Array): Promise<[RawFileEntry, Promise<void>]>;
-    putText(id: string, text: string): Promise<[RawFileEntry, Promise<void>]>;
-    putContent(id: string, content: Content): Promise<[RawFileEntry, Promise<void>]>;
-    putMetadata(id: string, metadata: Metadata): Promise<[RawFileEntry, Promise<void>]>;
-    putEntries(id: string, entries: RawEntry[]): Promise<[RawListEntry, Promise<void>]>;
+    putFile(id: string, bytes: Uint8Array): Promise<[RawEntry, Promise<void>]>;
+    putText(id: string, text: string): Promise<[RawEntry, Promise<void>]>;
+    putContent(id: string, content: Content): Promise<[RawEntry, Promise<void>]>;
+    putMetadata(id: string, metadata: Metadata): Promise<[RawEntry, Promise<void>]>;
+    putEntries(id: string, entries: RawEntry[], schemaVersion: SchemaVersion): Promise<[RawEntry, Promise<void>]>;
     uploadFile(visibleName: string, bytes: Uint8Array, mime: UploadMimeType): Promise<SimpleEntry>;
     dumpCache(): string;
     clearCache(): void;

package/dist/raw.js

@@ -1,7 +1,8 @@
-import { fromByteArray } from "base64-js";
 import CRC32C from "crc-32/crc32c";
 import { boolean, elements, empty, enumeration, float64, int32, nullable, properties, string, timestamp, uint8, uint32, values, } from "jtd-ts";
 import { ValidationError } from "./error.js";
+import { concatArrays } from "./utils.js";
+import "core-js/proposals/array-buffer-base64";
 const hashReg = /^[0-9a-f]{64}$/;
 const tag = properties({
     name: string(),
@@ -159,9 +160,29 @@ async function digest(buff) {
     const digest = await crypto.subtle.digest("SHA-256", 
     // NOTE this is type hinted wrong, but it does work correctly on a uint8 view
     buff);
-    return [...new Uint8Array(digest)]
-        .map((x) => x.toString(16).padStart(2, "0"))
-        .join("");
+    return new Uint8Array(digest).toHex();
+}
+function parseRawEntryLine(line) {
+    const [hash, type, id, subfiles, size] = line.split(":");
+    if (hash === undefined ||
+        type === undefined ||
+        id === undefined ||
+        subfiles === undefined ||
+        size === undefined) {
+        throw new Error(`line '${line}' was not formatted correctly`);
+    }
+    else if (type === "80000000" || type === "0") {
+        return {
+            hash,
+            type: type === "0" ? 0 : 80000000,
+            id,
+            subfiles: parseInt(subfiles, 10),
+            size: parseInt(size, 10),
+        };
+    }
+    else {
+        throw new Error(`line '${line}' was not formatted correctly`);
+    }
 }
 export class RawRemarkable {
     #authedFetch;
@@ -191,14 +212,14 @@ export class RawRemarkable {
         if (!rootHash.guardAssert(loaded))
             throw Error("invalid root hash");
         const { hash, generation, schemaVersion } = loaded;
-        if (schemaVersion !== 3) {
+        if (schemaVersion !== 3 && schemaVersion !== 4) {
             throw new Error(`schema version ${schemaVersion} not supported`);
         }
         else if (!Number.isSafeInteger(generation)) {
             throw new Error(`generation ${generation} was not a safe integer; please file a bug report`);
         }
         else {
-            return [hash, generation];
+            return [hash, generation, schemaVersion];
         }
     }
     async #getHash(hash) {
@@ -243,41 +264,30 @@ export class RawRemarkable {
     async getEntries(hash) {
         const rawFile = await this.getText(hash);
         const [version, ...rest] = rawFile.slice(0, -1).split("\n");
-        if (version !== "3") {
-            throw new Error(`schema version ${version} not supported`);
+        if (version === "3") {
+            return { entries: rest.map(parseRawEntryLine) };
+        }
+        else if (version === "4") {
+            const [info, ...remaining] = rest;
+            if (!info)
+                throw new Error("missing info line for schema version 4");
+            const [lead, id, count, size] = info.split(":");
+            if (lead !== "0" ||
+                id === undefined ||
+                count === undefined ||
+                size === undefined) {
+                throw new Error(`schema 4 info line '${info}' was not formatted correctly`);
+            }
+            const entries = remaining.map(parseRawEntryLine);
+            if (parseInt(count, 10) !== entries.length) {
+                throw new Error(`schema 4 expected ${count} entries, but found ${entries.length}`);
+            }
+            else {
+                return { entries, id, size: parseInt(size, 10) };
+            }
         }
         else {
-            return rest.map((line) => {
-                const [hash, type, id, subfiles, size] = line.split(":");
-                if (hash === undefined ||
-                    type === undefined ||
-                    id === undefined ||
-                    subfiles === undefined ||
-                    size === undefined) {
-                    throw new Error(`line '${line}' was not formatted correctly`);
-                }
-                else if (type === "80000000") {
-                    return {
-                        hash,
-                        type: 80000000,
-                        id,
-                        subfiles: parseInt(subfiles, 10),
-                        size: parseInt(size, 10),
-                    };
-                }
-                else if (type === "0" && subfiles === "0") {
-                    return {
-                        hash,
-                        type: 0,
-                        id,
-                        subfiles: 0,
-                        size: parseInt(size, 10),
-                    };
-                }
-                else {
-                    throw new Error(`line '${line}' was not formatted correctly`);
-                }
-            });
+            throw new Error(`schema version ${version} not supported`);
         }
     }
     async getContent(hash) {
@@ -341,7 +351,7 @@ export class RawRemarkable {
             const crc = CRC32C.buf(bytes, 0);
             const buff = new ArrayBuffer(4);
             new DataView(buff).setInt32(0, crc, false);
-            const crcHash = fromByteArray(new Uint8Array(buff));
+            const crcHash = new Uint8Array(buff).toBase64();
             await this.#authedFetch("PUT", `${this.#rawHost}/sync/v3/files/${hash}`, {
                 body: bytes,
                 headers: {
@@ -396,39 +406,55 @@ export class RawRemarkable {
             return await this.putText(id, JSON.stringify(metadata));
         }
     }
-    async putEntries(id, entries) {
-        // NOTE collections have a special hash function, the hash of their
+    async putEntries(id, entries, schemaVersion) {
+        // NOTE v3 collections have a special hash function, the hash of their
         // contents, so this needs to be different
         entries.sort((a, b) => a.id.localeCompare(b.id));
-        const hashBuff = new Uint8Array(entries.length * 32);
-        for (const [start, { hash }] of entries.entries()) {
-            for (const [i, byte] of (hash.match(/../g) ?? []).entries()) {
-                hashBuff[start * 32 + i] = parseInt(byte, 16);
-            }
-        }
-        const hash = await digest(hashBuff);
         const size = entries.reduce((acc, ent) => acc + ent.size, 0);
-        const records = ["3\n"];
+        const records = [`${schemaVersion}\n`];
+        if (schemaVersion === 4) {
+            const name = id === "root" ? "." : id;
+            records.push(`0:${name}:${entries.length}:${size}\n`);
+        }
         for (const { hash, type, id, subfiles, size } of entries) {
             records.push(`${hash}:${type}:${id}:${subfiles}:${size}\n`);
         }
+        const enc = new TextEncoder();
+        const entryBuff = enc.encode(records.join(""));
+        let hash;
+        if (schemaVersion === 3) {
+            // in schema version 3 an entry's hash is the hash of the concatenated hashes
+            const hashBuffs = [];
+            for (const { hash } of entries) {
+                hashBuffs.push(Uint8Array.fromHex(hash));
+            }
+            hash = await digest(concatArrays(hashBuffs));
+        }
+        else if (schemaVersion === 4) {
+            // in schema version 4 an entry's hash is the hash of the full entry file, same as everything else
+            hash = await digest(entryBuff);
+        }
+        else {
+            throw new Error(`unsupported schema version ${schemaVersion}`);
+        }
         const res = {
             id,
             hash,
-            type: 80000000,
+            type: schemaVersion > 3 ? 0 : 80000000,
             subfiles: entries.length,
             size,
         };
-        const enc = new TextEncoder();
         return [
             res,
             // NOTE when monitoring requests, this had the extension .docSchema appended, but I'm not entirely sure why
-            this.#putFile(hash, `${id}.docSchema`, enc.encode(records.join(""))),
+            this.#putFile(hash, `${id}.docSchema`, entryBuff),
         ];
     }
     async uploadFile(visibleName, bytes, mime) {
         const enc = new TextEncoder();
-        const meta = fromByteArray(enc.encode(JSON.stringify({ file_name: visibleName })));
+        const meta = enc
+            .encode(JSON.stringify({ file_name: visibleName }))
+            .toBase64();
         const resp = await this.#authedFetch("POST", `${this.#uploadHost}/doc/v2/files`, {
             body: bytes,
             headers: {