diff --git a/config.go b/config.go
index 8d89255..71d5f5d 100644
--- a/config.go
+++ b/config.go
@@ -24,10 +24,6 @@ type Config struct {
 		Secret     string
 		ExpireDays int
 	}
-
-	Storage struct {
-		Files string
-	}
 }
 
 func readConfig(fname string) (err error) {
diff --git a/file.go b/file.go
index 6dd1c75..9ad8457 100644
--- a/file.go
+++ b/file.go
@@ -5,47 +5,35 @@ import (
 	"github.com/jmoiron/sqlx"
 
 	// Standard
-	"fmt"
-	"os"
-	"path"
 	"time"
 )
 
 type File struct {
-	ID             int
-	UUID           string
-	UserID         int    `db:"user_id"`
-	Name           string `db:"name"`
-	Size           int
-	Type           string `db:"type"`
-	Modified       time.Time
-	UploadComplete bool `db:"upload_complete"`
+	ID       int
+	UserID   int `db:"user_id"`
+	NodeID   int `db:"node_id"`
+	Filename string
+	Size     int64
+	MIME     string
+	MD5      string
+	Uploaded time.Time
 }
 
-var (
-	fileUUIDCache map[string]int
-)
-
-func init() {
-	fileUUIDCache = make(map[string]int)
-}
-
-func AddFileToDb(userID int, file *File) (err error) { // {{{
+func AddFile(userID int, file *File) (err error) { // {{{
 	file.UserID = userID
 
 	var rows *sqlx.Rows
 	rows, err = db.Queryx(`
-		INSERT INTO public.file(user_id, uuid, name, size, type, modified, upload_complete)
-		VALUES($1, $2, $3, $4, $5, $6, false)
-		ON CONFLICT (user_id, uuid) DO UPDATE set name = public.file.name
+		INSERT INTO file(user_id, node_id, filename, size, mime, md5)
+		VALUES($1, $2, $3, $4, $5, $6)
 		RETURNING id
 		`,
 		file.UserID,
-		file.UUID,
-		file.Name,
+		file.NodeID,
+		file.Filename,
 		file.Size,
-		file.Type,
-		file.Modified,
+		file.MIME,
+		file.MD5,
 	)
 	if err != nil {
 		return
@@ -88,101 +76,5 @@ func Files(userID int, nodeUUID string, fileID int) (files []File, err error) {
 
 	return
 } // }}}
-func FileIDToPath(id int) (string, string) { // {{{
-	str := fmt.Sprintf("%012d", id)
-	dir := path.Join(config.Storage.Files, str[0:4], str[4:8])
-	fpath := path.Join(config.Storage.Files, str[0:4], str[4:8], str[8:12])
-	return dir, fpath
-} // }}}
-
-func FileWriteData(userID int, dbID int, data []byte, create bool) (err error) { // {{{
-	dir, fpath := FileIDToPath(dbID)
-	err = os.MkdirAll(dir, 0700)
-	if err != nil {
-		Log.Error("file", "error", err)
-		return
-	}
-
-	var f *os.File
-	if create {
-		f, err = os.OpenFile(fpath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
-	} else {
-		f, err = os.OpenFile(fpath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
-	}
-	if err != nil {
-		Log.Error("file", "error", err)
-		return
-	}
-	defer f.Close()
-
-	_, err = f.Write(data)
-	if err != nil {
-		Log.Error("file", "error", err)
-		return
-	}
-
-	return
-} // }}}
-
-func FileCountForUser(userID int) (count int, err error) { // {{{
-	row := db.QueryRowx(`SELECT COUNT(*) FROM public.file WHERE user_id = $1`, userID)
-	err = row.Scan(&count)
-	return
-} // }}}
-func FileServerUUIDsForUser(userID, page int) (uuids []string, more bool, err error) { // {{{
-	uuids = []string{}
-
-	var rows *sqlx.Rows
-	rows, err = db.Queryx(`
-		SELECT
-			uuid
-		FROM public.file
-		WHERE
-			user_id = $1
-		ORDER BY
-			uuid ASC
-		LIMIT $2 OFFSET $3
-		`,
-		userID,
-		SYNC_PAGINATION+1,
-		page*SYNC_PAGINATION,
-	)
-	if err != nil {
-		return
-	}
-	defer rows.Close()
-
-	var uuid string
-	for rows.Next() {
-		err = rows.Scan(&uuid)
-		if err != nil {
-			return
-		}
-		uuids = append(uuids, uuid)
-	}
-
-	more = len(uuids) > SYNC_PAGINATION
-	uuids = uuids[0:min(SYNC_PAGINATION, len(uuids))]
-
-	return
-} // }}}
-func FileMetadata(userID int, uuid string) (f File, err error) { // {{{
-	row := db.QueryRowx(`SELECT * FROM public.file WHERE user_id = $1 AND "uuid" = $2`, userID, uuid)
-	err = row.StructScan(&f)
-	return
-
-} // }}}
-func FileForUser(userID int, uuid string) (f *os.File, md File, err error) { // {{{
-	row := db.QueryRowx(`SELECT * FROM public.file WHERE user_id = $1 AND "uuid" = $2`, userID, uuid)
-	err = row.StructScan(&md)
-	if err != nil {
-		return
-	}
-
-	_, fpath := FileIDToPath(md.ID)
-	f, err = os.OpenFile(fpath, os.O_RDONLY, 0600)
-	return
-
-} // }}}
 
 // vim: foldmethod=marker
diff --git a/main.go b/main.go
index ff935ad..6e3cf94 100644
--- a/main.go
+++ b/main.go
@@ -5,6 +5,7 @@ import (
 	"notes2/authentication"
 	"notes2/html_template"
 	appUser "notes2/user"
+	"os"
 
 	// Standard
 	"bufio"
@@ -16,16 +17,14 @@ import (
 	"io"
 	"log/slog"
 	"net/http"
-	"os"
 	"path"
 	"regexp"
 	"strconv"
 	"strings"
 	"text/template"
-	"time"
 )
 
-const VERSION = "v30"
+const VERSION = "v29"
 const CONTEXT_USER = 1
 const SYNC_PAGINATION = 200
 
@@ -72,7 +71,7 @@ func init() { // {{{
 } // }}}
 func initLog() { // {{{
 	opts := slog.HandlerOptions{}
-	opts.Level = slog.LevelInfo
+	opts.Level = slog.LevelDebug
 	Log = slog.New(slog.NewJSONHandler(os.Stdout, &opts))
 } // }}}
 func main() { // {{{
@@ -142,17 +141,11 @@ func main() { // {{{
 	http.HandleFunc("/sync/from_server/count/{sequence}", authenticated(actionSyncFromServerCount))
 	http.HandleFunc("/sync/from_server/{sequence}/{offset}", authenticated(actionSyncFromServer))
 	http.HandleFunc("/sync/to_server", authenticated(actionSyncToServer))
-	http.HandleFunc("/sync/file/upload/{uuid}", authenticated(actionSyncFileUpload))
 
 	http.HandleFunc("/node/retrieve/{uuid}", authenticated(actionNodeRetrieve))
 	http.HandleFunc("/node/history/retrieve/{uuid}/{offset}", authenticated(actionNodeHistoryRetrieve))
 	http.HandleFunc("/node/history/count/{uuid}", authenticated(actionNodeHistoryCount))
 
-	http.HandleFunc("/file/count", authenticated(actionFileCount))
-	http.HandleFunc("/file/server_uuids/{offset}", authenticated(actionFileServerUUIDs))
-	http.HandleFunc("/file/uuid/{uuid}", authenticated(actionFile))
-	http.HandleFunc("/file/uuid/{uuid}/metadata", authenticated(actionFileMetadata))
-
 	http.HandleFunc("/service_worker.js", pageServiceWorker)
 
 	listen := fmt.Sprintf("%s:%d", config.Network.Address, config.Network.Port)
@@ -173,11 +166,6 @@ func authenticated(fn func(http.ResponseWriter, *http.Request)) func(http.Respon
 
 		// The Bearer token is extracted.
 		authHeader := r.Header.Get("Authorization")
-
-		if authHeader == "" {
-			authHeader = "Bearer " + r.URL.Query().Get("jwt")
-		}
-
 		authParts := RxpBearerToken.FindStringSubmatch(authHeader)
 		if len(authParts) != 2 {
 			failed(fmt.Errorf("Authorization missing or invalid"))
@@ -403,63 +391,6 @@ func actionSyncToServer(w http.ResponseWriter, r *http.Request) { // {{{
 		"OK": true,
 	})
 } // }}}
-func actionSyncFileUpload(w http.ResponseWriter, r *http.Request) { // {{{
-	uuid := r.PathValue("uuid")
-	session := getUserSession(r)
-
-	sentBytes, _ := strconv.Atoi(r.Header.Get("X-File-Sent-Bytes"))
-	totalBytes, _ := strconv.Atoi(r.Header.Get("X-File-Total-Bytes"))
-
-	// First block comes with file metadata.
-	file := File{}
-	if sentBytes == 0 {
-		file.UUID = uuid
-		file.Name = r.Header.Get("X-File-Name")
-		file.Size, _ = strconv.Atoi(r.Header.Get("X-File-Size"))
-		file.Type = r.Header.Get("X-File-Type")
-		modded, _ := strconv.ParseInt(r.Header.Get("X-File-Modified"), 10, 64)
-		file.Modified = time.UnixMilli(modded)
-		err := AddFileToDb(session.UserID, &file)
-		if err != nil {
-			Log.Error("upload", "op", "AddFileToDB", "error", err)
-			httpError(w, err)
-			return
-		}
-		fileUUIDCache[uuid] = file.ID
-	}
-
-	data, _ := io.ReadAll(r.Body)
-	var err error
-
-	switch sentBytes {
-	case 0:
-		// First block of data.
-		Log.Info("file_upload", "status", "new", "user", session.UserID, "uuid", uuid, "total", totalBytes)
-		id := fileUUIDCache[uuid]
-		err = FileWriteData(session.UserID, id, data, true)
-
-	case totalBytes:
-		// Last block of data - sent with 0 length data.
-		Log.Info("file_upload", "status", "done", "user", session.UserID, "uuid", uuid, "total", totalBytes)
-		id := fileUUIDCache[uuid]
-		delete(fileUUIDCache, uuid)
-		_, err = db.Exec(`UPDATE public.file SET upload_complete = true WHERE id = $1`, id) 
-
-	default:
-		id := fileUUIDCache[uuid]
-		err = FileWriteData(session.UserID, id, data, false)
-	}
-
-	if err != nil {
-		Log.Error("upload", "error", err)
-		httpError(w, err)
-		return
-	}
-
-	responseData(w, map[string]any{
-		"OK": true,
-	})
-} // }}}
 
 func actionUserGetPreferences(w http.ResponseWriter, r *http.Request) { // {{{
 	user := getUserSession(r)
@@ -502,65 +433,6 @@ func actionUserSetPreferences(w http.ResponseWriter, r *http.Request) { // {{{
 	})
 } // }}}
 
-func actionFileCount(w http.ResponseWriter, r *http.Request) {// {{{
-	session := getUserSession(r)
-	count, err := FileCountForUser(session.UserID)
-	if err != nil {
-		Log.Error("file_count", "error", err)
-		httpError(w, err)
-		return
-	}
-
-	responseData(w, map[string]any{
-		"OK": true,
-		"Count": count,
-	})
-}// }}}
-func actionFileServerUUIDs(w http.ResponseWriter, r *http.Request) {// {{{
-	session := getUserSession(r)
-	offset, _ := strconv.Atoi(r.PathValue("offset"))
-	uuids, more, err := FileServerUUIDsForUser(session.UserID, offset)
-	if err != nil {
-		Log.Error("file_server_uuids", "error", err)
-		httpError(w, err)
-		return
-	}
-
-	responseData(w, map[string]any{
-		"OK": true,
-		"UUIDs": uuids,
-		"MoreRowsExist": more,
-	})
-}// }}}
-func actionFile(w http.ResponseWriter, r *http.Request) {// {{{
-	uuid := r.PathValue("uuid")
-	session := getUserSession(r)
-	f, md, err := FileForUser(session.UserID, uuid)
-	if err != nil {
-		Log.Error("file_metadata", "error", err)
-		httpError(w, err)
-		return
-	}
-
-	http.ServeContent(w, r, md.Name, md.Modified, f)
-}// }}}
-func actionFileMetadata(w http.ResponseWriter, r *http.Request) {// {{{
-	uuid := r.PathValue("uuid")
-	session := getUserSession(r)
-	md, err := FileMetadata(session.UserID, uuid)
-
-	if err != nil {
-		Log.Error("file_metadata", "error", err)
-		httpError(w, err)
-		return
-	}
-
-	responseData(w, map[string]any{
-		"OK": true,
-		"Metadata": md,
-	})
-}// }}}
-
 func createNewUser(username string) { // {{{
 	reader := bufio.NewReader(os.Stdin)
 
diff --git a/node.go b/node.go
index 15f277b..a25c771 100644
--- a/node.go
+++ b/node.go
@@ -57,6 +57,67 @@ type Node struct {
 	Special          bool
 }
 
+func NodeTree(userID, offset int, synced uint64) (nodes []TreeNode, maxSeq uint64, moreRowsExist bool, err error) { // {{{
+	const LIMIT = 100
+	var rows *sqlx.Rows
+	rows, err = db.Queryx(`
+		SELECT
+			uuid,
+			COALESCE(parent_uuid, '') AS parent_uuid,
+			name,
+			created,
+			updated,
+			deleted IS NOT NULL AS deleted,
+			created_seq,
+			updated_seq,
+			deleted_seq
+		FROM
+			public.node
+		WHERE
+			user_id = $1 AND 
+			(
+				created_seq > $4 OR
+				updated_seq > $4 OR
+				deleted_seq > $4
+			)
+		ORDER BY
+			created ASC
+		LIMIT $2 OFFSET $3
+		`,
+		userID,
+		LIMIT+1,
+		offset,
+		synced,
+	)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+
+	nodes = []TreeNode{}
+	numNodes := 0
+	for rows.Next() {
+		// Query selects up to one more row than the decided limit.
+		// Saves one SQL query for row counting.
+		// Thus if numNodes is larger than the limit, more rows exist for the next call.
+		numNodes++
+		if numNodes > LIMIT {
+			moreRowsExist = true
+			return
+		}
+
+		node := TreeNode{}
+		if err = rows.StructScan(&node); err != nil {
+			return
+		}
+		nodes = append(nodes, node)
+
+		// DeletedSeq will be 0 if invalid, and thus not be a problem for the max function.
+		maxSeq = max(maxSeq, node.CreatedSeq, node.UpdatedSeq, uint64(node.DeletedSeq.Int64))
+	}
+
+	return
+} // }}}
 func Nodes(userID, offset int, synced uint64, clientUUID string) (nodes []Node, maxSeq uint64, moreRowsExist bool, err error) { // {{{
 	var rows *sqlx.Rows
 	rows, err = db.Queryx(`
diff --git a/sql/00011.sql b/sql/00011.sql
deleted file mode 100644
index f9efdbb..0000000
--- a/sql/00011.sql
+++ /dev/null
@@ -1,13 +0,0 @@
-CREATE TABLE public.file (
-	id serial NOT NULL,
-	user_id int4 NOT NULL,
-	uuid uuid NOT NULL,
-	name varchar DEFAULT '' NOT NULL,
-	"size" int DEFAULT 0 NOT NULL,
-	"type" varchar DEFAULT 'application/octet-stream' NOT NULL,
-	modified timestamptz DEFAULT NOW() NOT NULL,
-	CONSTRAINT file_pk PRIMARY KEY (id),
-	CONSTRAINT file_user_fk FOREIGN KEY (user_id) REFERENCES public."user"(id) ON DELETE RESTRICT ON UPDATE RESTRICT
-);
-
-ALTER TABLE public.file ADD CONSTRAINT file_user_uuid_unique UNIQUE (user_id,"uuid");
diff --git a/sql/00012.sql b/sql/00012.sql
deleted file mode 100644
index 422d2cf..0000000
--- a/sql/00012.sql
+++ /dev/null
@@ -1 +0,0 @@
-ALTER TABLE public.file ADD upload_complete bool DEFAULT false NOT NULL;
diff --git a/sql/00013.sql b/sql/00013.sql
deleted file mode 100644
index ef7e72c..0000000
--- a/sql/00013.sql
+++ /dev/null
@@ -1,171 +0,0 @@
--- file_node_links Keeps tracks of the files referenced by each node.
-CREATE TABLE public.file_node_links (
-	file_uuid uuid NOT NULL,
-	node_uuid uuid NOT NULL,
-	user_id int4 NOT NULL,
-	CONSTRAINT file_node_pk PRIMARY KEY (file_uuid,node_uuid,user_id),
-	CONSTRAINT file_node_user_fk FOREIGN KEY (user_id) REFERENCES public."user"(id) ON DELETE CASCADE ON UPDATE CASCADE,
-	CONSTRAINT file_node_node_fk FOREIGN KEY (user_id,node_uuid) REFERENCES public.node(user_id,"uuid") ON DELETE CASCADE ON UPDATE CASCADE,
-	CONSTRAINT file_node_file_fk FOREIGN KEY (user_id,file_uuid) REFERENCES public.file(user_id,"uuid") ON DELETE CASCADE ON UPDATE CASCADE
-);
-
--- add_nodes needs to call the new manage_node_file_links procedure.
-CREATE OR REPLACE PROCEDURE public.add_nodes(IN p_user_id integer, IN p_client_uuid uuid, IN p_nodes jsonb)
- LANGUAGE plpgsql
-AS $procedure$
-
-DECLARE
-	node_data         jsonb;
-	node_updated      timestamptz;
-	db_updated        timestamptz;
-	db_uuid           uuid;
-	db_client         uuid;
-	db_history_uuid   uuid;
-	node_uuid         uuid;
-	node_parent_uuid  uuid;
-	node_history_uuid uuid;
-
-BEGIN
-	FOR node_data IN SELECT * FROM jsonb_array_elements(p_nodes)
-	LOOP
-		node_uuid         = (node_data->>'UUID')::uuid;
-		node_history_uuid = (node_data->>'HistoryUUID')::uuid;
-		node_updated      = (node_data->>'Updated')::timestamptz;
-
-
-
-		-- Frontend is using an all-zero UUID to define the root node.
-		-- Database is using NULL.
-		IF node_data->>'ParentUUID' = '00000000-0000-0000-0000-000000000000' OR node_data->>'ParentUUID' = '' THEN
-			node_parent_uuid = NULL;
-		ELSE
-			node_parent_uuid = (node_data->>'ParentUUID')::uuid;
-		END IF;
-
-		-- Safeguard against being your own parent.
-		IF node_uuid = node_parent_uuid THEN
-			RAISE EXCEPTION 'Node UUID is same as node parent UUID.' USING ERRCODE = 'XPRNT';
-		END IF;
-
-
-		-- Every jode has a new history UUID to keep the history entry uniquely identifiable
-		-- across clients. A history entry could potentially be sent again, but should be
-		-- safe to ignore as every change to a node should have a new history UUID.
-		--
-		-- The current node is also stored as history.
-		INSERT INTO node_history(
-			user_id, "uuid", "history_uuid", parents, created, updated,
-			"name", "content", "content_encrypted",
-			client
-		)
-		VALUES(
-			p_user_id, -- combined key
-			node_uuid, -- combined key
-			node_history_uuid, -- combined key
-			(jsonb_populate_record(null::json_ancestor_array, node_data))."Ancestors",
-			COALESCE((node_data->>'Created')::timestamptz, NOW()),
-			COALESCE((node_data->>'Updated')::timestamptz, NOW()),
-			(node_data->>'Name')::varchar,
-			(node_data->>'Content')::text,
-			'', /* content_encrypted */
-			p_client_uuid
-		)
-		ON CONFLICT ("user_id", "uuid", "history_uuid")
-		DO NOTHING;
-
-
-
-		-- Retrieve the current modified timestamp for this node from the database.
-		SELECT
-			uuid, updated, client
-		INTO
-			db_uuid, db_updated, db_client
-		FROM public."node"
-		WHERE
-			user_id = p_user_id AND
-			uuid::uuid = node_uuid::uuid;
-
-
-
-		-- Is the node not in database? It needs to be created.
-		IF db_uuid IS NULL THEN
-			RAISE NOTICE '01 New node %', node_uuid;
-
-			INSERT INTO public."node" (
-				user_id, "uuid", parent_uuid, created, updated,
-				"name", "content", "content_encrypted",
-				client
-			)
-			VALUES(
-				p_user_id,
-				node_uuid,
-				node_parent_uuid,
-				COALESCE((node_data->>'Created')::timestamptz, NOW()),
-				COALESCE((node_data->>'Updated')::timestamptz, NOW()),
-				(node_data->>'Name')::varchar,
-				(node_data->>'Content')::text,
-				'', /* content_encrypted */
-				p_client_uuid
-			);
-
-			-- Remove/insert file links for the newest content of this node.
-			CALL manage_node_file_links(p_user_id, node_uuid, (node_data->>'Content')::text);
-
-			CONTINUE;
-		END IF;
-
-
-
-		-- Update the public node as well if it was older than incoming node.
-		IF node_updated > db_updated THEN
-			UPDATE public."node"
-			SET
-				updated = (node_data->>'Updated')::timestamptz,
-				updated_seq = nextval('node_updates'),
-				parent_uuid = node_parent_uuid,
-				name = (node_data->>'Name')::varchar,
-				content = (node_data->>'Content')::text,
-				client = p_client_uuid
-			WHERE
-				user_id = p_user_id AND
-				uuid::uuid = node_uuid::uuid;
-
-			-- Remove/insert file links for the newest content of this node.
-			CALL manage_node_file_links(p_user_id, node_uuid, (node_data->>'Content')::text);
-		END IF;
-
-	END LOOP;
-END
-$procedure$
-;
-
-CREATE OR REPLACE PROCEDURE public.manage_node_file_links(IN p_user_id integer, IN p_node_uuid uuid, IN p_node_content text)
-LANGUAGE plpgsql
-AS $fn$
-BEGIN
-
-	-- Old file links are purged to get rid of deleted ones.
-	-- New links will be added from latest node update.
-	DELETE FROM file_node_links
-	WHERE
-		user_id = p_user_id AND
-		node_uuid = p_node_uuid;
-
-	-- db:// URLs are extracted from the content to manage them in a separate table.
-	WITH file_uuids AS (
-		SELECT regexp_matches(
-			p_node_content,
-			'db://([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})',
-			'g'
-		) AS file_uuid
-	) 
-	INSERT INTO file_node_links(user_id, node_uuid, file_uuid)
-	SELECT
-		p_user_id,
-		p_node_uuid,
-		(file_uuid[1])::uuid
-	FROM file_uuids;
-
-END
-$fn$
-;
diff --git a/static/images/icon_storage.svg b/static/images/icon_storage.svg
deleted file mode 100644
index 563d355..0000000
--- a/static/images/icon_storage.svg
+++ /dev/null
@@ -1,49 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   width="21.333317"
-   height="24"
-   viewBox="0 0 5.64444 6.35"
-   version="1.1"
-   id="svg1"
-   inkscape:version="1.4.4 (dcaf3e7d9e, 2026-05-05)"
-   sodipodi:docname="icon_storage.svg"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <sodipodi:namedview
-     id="namedview1"
-     pagecolor="#ffffff"
-     bordercolor="#000000"
-     borderopacity="0.25"
-     inkscape:showpageshadow="2"
-     inkscape:pageopacity="0.0"
-     inkscape:pagecheckerboard="0"
-     inkscape:deskcolor="#d1d1d1"
-     inkscape:document-units="px"
-     inkscape:zoom="1"
-     inkscape:cx="-56"
-     inkscape:cy="-9.5"
-     inkscape:window-width="2190"
-     inkscape:window-height="1401"
-     inkscape:window-x="1463"
-     inkscape:window-y="0"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="layer1" />
-  <defs
-     id="defs1" />
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(-288.92499,-115.8875)">
-    <title
-       id="title1">database</title>
-    <path
-       d="m 291.74722,115.8875 c -1.55928,0 -2.82223,0.63146 -2.82223,1.4111 0,0.77964 1.26295,1.41112 2.82223,1.41112 1.55927,0 2.82221,-0.63148 2.82221,-1.41112 0,-0.77964 -1.26294,-1.4111 -2.82221,-1.4111 m -2.82223,2.11666 v 1.05834 c 0,0.77964 1.26295,1.4111 2.82223,1.4111 1.55927,0 2.82221,-0.63146 2.82221,-1.4111 v -1.05834 c 0,0.77964 -1.26294,1.41111 -2.82221,1.41111 -1.55928,0 -2.82223,-0.63147 -2.82223,-1.41111 m 0,1.7639 v 1.05833 c 0,0.77964 1.26295,1.41111 2.82223,1.41111 1.55927,0 2.82221,-0.63147 2.82221,-1.41111 v -1.05833 c 0,0.77964 -1.26294,1.4111 -2.82221,1.4111 -1.55928,0 -2.82223,-0.63146 -2.82223,-1.4111 z"
-       id="path1"
-       style="stroke-width:0.264583" />
-  </g>
-</svg>
diff --git a/static/js/api.mjs b/static/js/api.mjs
index 9b53cbf..26a19de 100644
--- a/static/js/api.mjs
+++ b/static/js/api.mjs
@@ -15,61 +15,18 @@ export class API {
 			const res = await fetch(path, { method, headers, body })
 			// An HTTP communication level error occured.
 			if (!res.ok || res.status != 200)
-				throw new Error('HTTP error', { cause: { type: 'http', error: res, } })
+				throw new Error('HTTP error', { cause: { type: 'http', error: res, }})
 
 			// Application level response are handled here.
 			const json = await res.json()
 			if (!json.OK)
-				throw new Error(json.Error, { cause: { type: 'application', application: json, } })
-
-			return json
-		} catch (err) {
-			// Catch any other errors from fetch.
-			throw new Error(err.message, { cause: { type: 'http', error: err, } })
-		}
-	}
-
-	// Sends a block of binary data to server.
-	static async upload(uuid, data, sentBytes, metadata) {
-		try {
-			const path = `/sync/file/upload/${uuid}`
-			const headers = {
-				'X-File-Sent-Bytes': sentBytes,
-				'X-File-Total-Bytes': metadata.size,
-			}
-
-			// Metadata is needed for the database.
-			// No need to send it every block.
-			if (sentBytes === 0) {
-				headers['X-File-Name'] = metadata.name
-				headers['X-File-Size'] = metadata.size
-				headers['X-File-Type'] = metadata.type
-				headers['X-File-Modified'] = metadata.modified
-			}
-
-			// Authentication is done with a bearer token.
-			// Here provided to the backend if set.
-			const token = localStorage.getItem('token')
-			if (token) {
-				headers.Authorization = `Bearer ${token}`
-			}
-
-			const res = await fetch(path, { method: 'POST', headers, body: data })
-			// An HTTP communication level error occured.
-			if (!res.ok || res.status != 200)
-				throw new Error('HTTP error', { cause: { type: 'http', error: res, } })
-
-			// Application level response are handled here.
-			const json = await res.json()
-			if (!json.OK)
-				throw new Error(json.Error, { cause: { type: 'application', application: json, } })
+				throw new Error(json.Error, { cause: { type: 'application', application: json, }})
 
 			return json
 
 		} catch (err) {
 			// Catch any other errors from fetch.
-			console.error(err)
-			throw new Error(err, { cause: { type: 'http', error: err } })
+			throw new Error(err.message, { cause: { type: 'http', error: err, }})
 		}
 	}
 
diff --git a/static/js/app.mjs b/static/js/app.mjs
index e44eabd..90bad39 100644
--- a/static/js/app.mjs
+++ b/static/js/app.mjs
@@ -1,6 +1,7 @@
-import { ROOT_NODE, Node } from 'node_store'
+import { ROOT_NODE } from 'node_store'
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
 import { N2Sidebar } from 'sidebar'
+import { Node } from 'node'
 import { N2PreferenceSet } from './page_preferences.mjs'
 
 export class App {
@@ -65,10 +66,11 @@ export class App {
 
 		_mbus.subscribe('DEVICE_PREFERENCE_SET_UPDATED', ()=>{
 			this.preferences = this.getPreferences()
+			console.log(this.preferences.data)
 		})
 
-		globalThis.addEventListener('keydown', event => this.keyHandler(event))
-		globalThis.addEventListener('popstate', event => this.popState(event))
+		window.addEventListener('keydown', event => this.keyHandler(event))
+		window.addEventListener('popstate', event => this.popState(event))
 		document.getElementById('notes2').addEventListener('click', event => {
 			if (event.target.id === 'notes2')
 				document.getElementById('node-content')?.focus()
@@ -79,12 +81,12 @@ export class App {
 
 		_mbus.dispatch('SHOW_PAGE', { page: 'node' })
 
-		globalThis._sync = new Sync()
+		window._sync = new Sync()
 
 		// I think it is uncomfortable having the sync running as soon as the page load.
 		// I haven't gotten the time to look at the page before stuff jumps around.
 		// There a slight delay to initiate sync seems reasonable.
-		setTimeout(() => globalThis._sync.run(), 1000)
+		setTimeout(() => window._sync.run(), 1000)
 	}// }}}
 	keyHandler(event) {//{{{
 		let handled = true
diff --git a/static/js/crypto.mjs b/static/js/crypto.mjs
new file mode 100644
index 0000000..9aab255
--- /dev/null
+++ b/static/js/crypto.mjs
@@ -0,0 +1,72 @@
+export default class Crypto {
+	constructor(key) {//{{{
+		if(key === null)
+			throw new Error("No key provided")
+
+		if(typeof key === 'string')
+			this.key = sjcl.codec.base64.toBits(base64_key)
+		else
+			this.key = key
+
+		this.aes = new sjcl.cipher.aes(this.key)
+	}//}}}
+
+	static generate_key() {//{{{
+		return sjcl.random.randomWords(8)
+	}//}}}
+	static pass_to_key(pass, salt = null) {//{{{
+		if(salt === null)
+			salt = sjcl.random.randomWords(4) // 128 bits (16 bytes)
+		let key = sjcl.misc.pbkdf2(pass, salt, 10000)
+
+		return {
+			salt,
+			key,
+		}
+	}//}}}
+
+	encrypt(plaintext_data_in_bits, counter, return_encoded = true) {//{{{
+		// 8 bytes of random data, (1 word = 4 bytes) * 2
+		// with 8 bytes of byte encoded counter is used as
+		// IV to guarantee a non-repeated IV (which is a catastrophe).
+		// Assumes counter value is kept unique. Counter is taken from
+		// Postgres sequence.
+		let random_bits = sjcl.random.randomWords(2)
+		let iv_bytes = sjcl.codec.bytes.fromBits(random_bits)
+		for (let i = 0; i < 8; ++i) {
+			let mask = 0xffn << BigInt(i*8)
+			let counter_i_byte = (counter & mask) >> BigInt(i*8)
+			iv_bytes[15-i] = Number(counter_i_byte)
+		}
+		let iv = sjcl.codec.bytes.toBits(iv_bytes)
+
+		let encrypted = sjcl.mode['ccm'].encrypt(
+			this.aes,
+			plaintext_data_in_bits,
+			iv,
+		)
+
+		// Returning 16 bytes (4 words) IV + encrypted data.
+		if(return_encoded)
+			return sjcl.codec.base64.fromBits(
+				iv.concat(encrypted)
+			)
+		else
+			return iv.concat(encrypted)
+	}//}}}
+	decrypt(encrypted_base64_data) {//{{{
+		try {
+			let encoded = sjcl.codec.base64.toBits(encrypted_base64_data)
+			let iv = encoded.slice(0, 4) // in words (4 bytes), not bytes
+			let encrypted_data = encoded.slice(4)
+			return sjcl.mode['ccm'].decrypt(this.aes, encrypted_data, iv)
+		} catch(err) {
+			if(err.message == `ccm: tag doesn't match`)
+				throw('Decryption failed')
+			else
+				throw(err)
+		}
+	}//}}}
+}
+
+// vim: foldmethod=marker
diff --git a/static/js/file.mjs b/static/js/file.mjs
index 8e3bb94..4322218 100644
--- a/static/js/file.mjs
+++ b/static/js/file.mjs
@@ -1,8 +1,7 @@
 import { CustomHTMLElement } from "./lib/custom_html_element.mjs";
-import { API } from 'api'
 
 export class N2File extends CustomHTMLElement {
-	static {// {{{
+	static {
 		this.tmpl = document.createElement('template')
 		this.tmpl.innerHTML = `
 			<style>
@@ -31,64 +30,24 @@ export class N2File extends CustomHTMLElement {
 			<img data-el="image" src="/images/${_VERSION}/file_icons/generic.svg">
 			<div data-el="filename"></div>
 		`
-	}// }}}
-	constructor() {// {{{
+	}
+	constructor() {
 		super(true)
 
-		this.streamLocalFile = false
-		this.uuid = null
-
 		this.addEventListener('click', event => {
 			event.preventDefault()
 			event.stopPropagation()
 
-			// Download to disk.
-			if (event.shiftKey) {
-				this.downloadToDisk()
-				return
-			}
-
-			// Open in browser.
-			this.openInBrowser(event)
+			window.open(
+				URL.createObjectURL(this.file),
+				(event.ctrlKey || event.shiftKey) ? '_blank' : '_self',
+			)
 		})
 
 		this.render()
-	}// }}}
-	openInBrowser(event) {// {{{
-		if (this.streamLocalFile)
-			window.open(
-				`/stream-local?uuid=${this.metadata.UUID}`,
-				event.ctrlKey ? '_blank' : '_self',
-			)
-		else {
-			const jwt = localStorage.getItem('token')
-			window.open(
-				`/file/uuid/${this.uuid}?jwt=${jwt}`,
-				event.ctrlKey ? '_blank' : '_self',
-			)
-		}
-	}// }}}
-	async downloadToDisk() {// {{{
-		try {
-			// TODO: implement download of remote content.
-			if (this.streamLocalFile === false)
-				throw new Error('This file is only available online. Download not implemented yet.')
+	}
 
-			const handle = await window.showSaveFilePicker({
-				suggestedName: this.metadata.name,
-			})
-
-			const writable = await handle.createWritable()
-			const blobStream = await globalThis.nodeStore.fileSegments.getStream(this.uuid)
-			await blobStream.pipeTo(writable)
-		} catch (err) {
-			if (err.name == 'AbortError')
-				return
-			console.error(err)
-			alert(err.message)
-		}
-	}// }}}
-	async render() {// {{{
+	async render() {
 		const src = this.getAttribute('src')
 
 		// N2's db:// URLs are fetched from IndexedDB.
@@ -97,62 +56,26 @@ export class N2File extends CustomHTMLElement {
 			// while Marked lib has to be returned a string when exiting this function.
 			// populateImg makes sure this returned img element exists and then populates it
 			// with the image from IndexedDB.
-			const fileUUID = src.slice(5)
+			const file = await globalThis.nodeStore.files.get(src.slice(5))
+			if (!file)
+				return
+			this.file = file.file
 
-			this.uuid = fileUUID
-			const md = await globalThis.nodeStore.filesMetadata.get(fileUUID)
+			if (file.file.type.startsWith('image/'))
+				this.elImage.src = URL.createObjectURL(file.file)
+			else {
+				// Check for and use an existing MIME type icon.
+				// Place them in static/images/file_icons/ and replace the slash with an underscore.
+				const url = `/images/${_VERSION}/file_icons/${file.file.type.replaceAll('/', '_')}.svg`
+				const res = await fetch(url)
+				if (res.ok)
+					this.elImage.src = url
 
-			if (md) {
-				this.metadata = md
-				this.streamLocalFile = true
-				this.renderLocalFile(md)
-			} else {
-				/* <file> can be undefined when a node is retrieved but files aren't synced.
-				 * Try to show from server.
-				 *
-				 * Metadata is needed to know whether to display an image or the file representation. */
-				try {
-					const res = await API.query('GET', `/file/uuid/${fileUUID}/metadata`)
-					this.renderRemoteFile(res.Metadata)
-				} catch (err) {
-					console.error(err)
-				}
+				this.elFilename.innerText = file.file.name
+				this.elFilename.style.display = 'block'
 			}
-
 		} else
-			// Probably an external URL.
 			this.elImage.src = src
-	}// }}}
-	async renderLocalFile(fileMetadata) {// {{{
-		if (fileMetadata.type.startsWith('image/'))
-			this.elImage.src = `/stream-local?uuid=${fileMetadata.UUID}`
-		else {
-			// Check for and use an existing MIME type icon.
-			// Place them in static/images/file_icons/ and replace the slash with an underscore.
-			const url = `/images/${_VERSION}/file_icons/${fileMetadata.type.replaceAll('/', '_')}.svg`
-			const res = await fetch(url)
-			if (res.ok)
-				this.elImage.src = url
-
-			this.elFilename.innerText = fileMetadata.name
-			this.elFilename.style.display = 'block'
-		}
-	}// }}}
-	async renderRemoteFile(md) {// {{{
-		if (md.Type.startsWith('image/')) {
-			const jwt = localStorage.getItem('token')
-			this.elImage.src = `/file/uuid/${md.UUID}?jwt=${jwt}`
-		} else {
-			// Check for and use an existing MIME type icon.
-			// Place them in static/images/file_icons/ and replace the slash with an underscore.
-			const url = `/images/${_VERSION}/file_icons/${md.Type.replaceAll('/', '_')}.svg`
-			const res = await fetch(url)
-			if (res.ok)
-				this.elImage.src = url
-
-			this.elFilename.innerText = md.Name
-			this.elFilename.style.display = 'block'
-		}
-	}// }}}
+	}
 }
 customElements.define('n2-file', N2File)
diff --git a/static/js/key.mjs b/static/js/key.mjs
new file mode 100644
index 0000000..1f8c40f
--- /dev/null
+++ b/static/js/key.mjs
@@ -0,0 +1,240 @@
+import { h, Component } from 'preact'
+import htm from 'htm'
+import Crypto from 'crypto'
+const html = htm.bind(h)
+
+export class Keys extends Component {
+	constructor(props) {//{{{
+		super(props)
+		this.state = {
+			create: false,
+		}
+
+		props.nodeui.retrieveKeys()
+	}//}}}
+	render({ nodeui }, { create }) {//{{{
+		let keys = nodeui.keys.value
+			.sort((a,b)=>{
+				if(a.description < b.description) return -1
+				if(a.description > b.description) return  1
+				return 0
+			})
+			.map(key=>
+				html`<${KeyComponent} key=${`key-${key.ID}`} model=${key} />`
+			)
+
+		let createButton = ''
+		let createComponents = ''
+		if(create) {
+			createComponents = html`
+			<div id="key-create">
+				<h2>New key</h2>
+
+				<div class="fields">
+					<input type="text" id="key-description" placeholder="Name" />
+
+					<input type="password" id="key-pass1" placeholder="Password" />
+					<input type="password" id="key-pass2" placeholder="Repeat password" />
+
+					<textarea id="key-key" placeholder="Key"></textarea>
+
+					<div>
+						<button class="generate" onclick=${()=>this.generateKey()}>Generate</button>
+						<button class="create" onclick=${()=>this.createKey()}>Create</button>
+					</div>
+				</div>
+			</div>
+			`
+		} else {
+			createButton = html`<div style="margin-top: 16px;"><button onclick=${()=>this.setState({ create: true })}>Create new key</button></div>`
+		}
+
+		return html`
+			<div id="keys">
+				<h1>Encryption keys</h1>
+				<p>
+					Unlock a key by clicking its name. Lock it by clicking it again.
+				</p>
+
+				<p>
+					Copy the key and store it in a very secure place to have a way to access notes
+					in case the password is forgotten, or database is corrupted.
+				</p>
+
+				<p>Click "View key" after unlocking it.</p>
+
+				${createButton}
+				${createComponents}
+
+				<h2>Keys</h2>
+				<div class="key-list">
+					${keys}
+				</div>
+			</div>`
+	}//}}}
+
+	generateKey() {//{{{
+		let keyTextarea = document.getElementById('key-key')
+		let key = sjcl.codec.hex.fromBits(Crypto.generate_key()).replace(/(....)/g, '$1 ').trim()
+		keyTextarea.value = key
+	}//}}}
+	validateNewKey() {//{{{
+		let keyDescription = document.getElementById('key-description').value
+		let keyTextarea = document.getElementById('key-key').value
+		let pass1 = document.getElementById('key-pass1').value
+		let pass2 = document.getElementById('key-pass2').value
+
+		if(keyDescription.trim() == '')
+			throw new Error('The key has to have a description')
+
+		if(pass1.trim() == '' || pass1.length < 4)
+			throw new Error('The password has to be at least 4 characters long.')
+
+		if(pass1 != pass2)
+			throw new Error(`Passwords doesn't match`)
+
+		let cleanKey = keyTextarea.replace(/\s+/g, '')
+		if(!cleanKey.match(/^[0-9a-f]{64}$/i))
+			throw new Error('Invalid key - has to be 64 characters of 0-9 and A-F')
+	}//}}}
+	createKey() {//{{{
+		try {
+			this.validateNewKey()
+
+			let description = document.getElementById('key-description').value
+			let keyAscii = document.getElementById('key-key').value
+			let pass1 = document.getElementById('key-pass1').value
+
+			// Key in hex taken from user.
+			let actual_key = sjcl.codec.hex.toBits(keyAscii.replace(/\s+/g, ''))
+
+			// Key generated from password, used to encrypt the actual key.
+			let pass_gen = Crypto.pass_to_key(pass1)
+
+			let crypto = new Crypto(pass_gen.key)
+			let encrypted_actual_key = crypto.encrypt(actual_key, 0x1n, false)
+
+			// Database value is salt + actual key, needed to generate the same key from the password.
+			let db_encoded = sjcl.codec.hex.fromBits(
+				pass_gen.salt.concat(encrypted_actual_key)
+			)
+
+			// Create on server.
+			window._app.current.request('/key/create', {
+				description,
+				key: db_encoded,
+			})
+			.then(res=>{
+				let key = new Key(res.Key, this.props.nodeui.keyCounter)
+				this.props.nodeui.keys.value = this.props.nodeui.keys.value.concat(key)
+			})
+			.catch(window._app.current.responseError)
+		} catch(err) {
+			alert(err.message)
+			return
+		}
+	}//}}}
+}
+
+export class Key {
+	constructor(data, counter_callback) {//{{{
+		this.ID           = data.ID
+		this.description  = data.Description
+		this.encryptedKey = data.Key
+		this.key          = null
+
+		this._counter_cbk = counter_callback
+
+		let hex_key = window.sessionStorage.getItem(`key-${this.ID}`)
+		if(hex_key)
+			this.key = sjcl.codec.hex.toBits(hex_key)
+	}//}}}
+	status() {//{{{
+		if(this.key === null)
+			return 'locked'
+		return 'unlocked'
+	}//}}}
+	lock() {//{{{
+		this.key = null
+		window.sessionStorage.removeItem(`key-${this.ID}`)
+	}//}}}
+	unlock(password) {//{{{
+		let db = sjcl.codec.hex.toBits(this.encryptedKey)
+		let salt = db.slice(0, 4)
+		let pass_key = Crypto.pass_to_key(password, salt)
+		let crypto = new Crypto(pass_key.key)
+		this.key = crypto.decrypt(sjcl.codec.base64.fromBits(db.slice(4)))
+		window.sessionStorage.setItem(`key-${this.ID}`, sjcl.codec.hex.fromBits(this.key))
+	}//}}}
+	async counter() {//{{{
+		return this._counter_cbk()
+	}//}}}
+}
+
+export class KeyComponent extends Component {
+	constructor({ model }) {//{{{
+		super({ model })
+		this.state = {
+			show_key: false,
+		}
+	}//}}}
+	render({ model }, { show_key }) {//{{{
+		let status = ''
+		switch(model.status()) {
+			case 'locked':
+				status = html`<div class="status locked"><img src="/images/${window._VERSION}/padlock-closed.svg" /></div>`
+				break
+
+			case 'unlocked':
+				status = html`<div class="status unlocked"><img src="/images/${window._VERSION}/padlock-open.svg" /></div>`
+				break
+		}
+
+		let hex_key = ''
+		if(show_key) {
+			if(model.status() == 'locked')
+				hex_key = html`<div class="hex-key">Unlock key first</div>`
+			else {
+				let key = sjcl.codec.hex.fromBits(model.key)
+				key = key.replace(/(....)/g, "$1 ").trim()
+				hex_key = html`<div class="hex-key">${key}</div>`
+			}
+		}
+
+		let unlocked = model.status()=='unlocked'
+
+		return html`
+			<div class="status" onclick=${()=>this.toggle()}>${status}</div>
+			<div class="description" onclick=${()=>this.toggle()}>${model.description}</div>
+			<div class="view" onclick=${()=>this.toggleViewKey()}>${unlocked ? 'View key' : ''}</div>
+			${hex_key}
+		`
+	}//}}}
+	toggle() {//{{{
+		if(this.props.model.status() == 'locked')
+			this.unlock()
+		else
+			this.lock()
+	}//}}}
+	lock() {//{{{
+		this.props.model.lock()
+		this.forceUpdate()
+	}//}}}
+	unlock() {//{{{
+		let pass = prompt("Password")
+		if(!pass)
+			return
+
+		try {
+			this.props.model.unlock(pass)
+			this.forceUpdate()
+		} catch(err) {
+			alert(err)
+		}
+	}//}}}
+	toggleViewKey() {//{{{
+		this.setState({ show_key: !this.state.show_key })
+	}//}}}
+}
+
+// vim: foldmethod=marker
diff --git a/static/js/lib/sjcl.js b/static/js/lib/sjcl.js
new file mode 100644
index 0000000..b5a1021
--- /dev/null
+++ b/static/js/lib/sjcl.js
@@ -0,0 +1,2574 @@
+/** @fileOverview Javascript cryptography implementation.
+ *
+ * Crush to remove comments, shorten variable names and
+ * generally reduce transmission size.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+"use strict";
+/*jslint indent: 2, bitwise: false, nomen: false, plusplus: false, white: false, regexp: false */
+/*global document, window, escape, unescape, module, require, Uint32Array */
+
+/**
+ * The Stanford Javascript Crypto Library, top-level namespace.
+ * @namespace
+ */
+var sjcl = {
+  /**
+   * Symmetric ciphers.
+   * @namespace
+   */
+  cipher: {},
+
+  /**
+   * Hash functions.  Right now only SHA256 is implemented.
+   * @namespace
+   */
+  hash: {},
+
+  /**
+   * Key exchange functions.  Right now only SRP is implemented.
+   * @namespace
+   */
+  keyexchange: {},
+  
+  /**
+   * Cipher modes of operation.
+   * @namespace
+   */
+  mode: {},
+
+  /**
+   * Miscellaneous.  HMAC and PBKDF2.
+   * @namespace
+   */
+  misc: {},
+  
+  /**
+   * Bit array encoders and decoders.
+   * @namespace
+   *
+   * @description
+   * The members of this namespace are functions which translate between
+   * SJCL's bitArrays and other objects (usually strings).  Because it
+   * isn't always clear which direction is encoding and which is decoding,
+   * the method names are "fromBits" and "toBits".
+   */
+  codec: {},
+  
+  /**
+   * Exceptions.
+   * @namespace
+   */
+  exception: {
+    /**
+     * Ciphertext is corrupt.
+     * @constructor
+     */
+    corrupt: function(message) {
+      this.toString = function() { return "CORRUPT: "+this.message; };
+      this.message = message;
+    },
+    
+    /**
+     * Invalid parameter.
+     * @constructor
+     */
+    invalid: function(message) {
+      this.toString = function() { return "INVALID: "+this.message; };
+      this.message = message;
+    },
+    
+    /**
+     * Bug or missing feature in SJCL.
+     * @constructor
+     */
+    bug: function(message) {
+      this.toString = function() { return "BUG: "+this.message; };
+      this.message = message;
+    },
+
+    /**
+     * Something isn't ready.
+     * @constructor
+     */
+    notReady: function(message) {
+      this.toString = function() { return "NOT READY: "+this.message; };
+      this.message = message;
+    }
+  }
+};
+/** @fileOverview Low-level AES implementation.
+ *
+ * This file contains a low-level implementation of AES, optimized for
+ * size and for efficiency on several browsers.  It is based on
+ * OpenSSL's aes_core.c, a public-domain implementation by Vincent
+ * Rijmen, Antoon Bosselaers and Paulo Barreto.
+ *
+ * An older version of this implementation is available in the public
+ * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,
+ * Stanford University 2008-2010 and BSD-licensed for liability
+ * reasons.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * Schedule out an AES key for both encryption and decryption.  This
+ * is a low-level class.  Use a cipher mode to do bulk encryption.
+ *
+ * @constructor
+ * @param {Array} key The key as an array of 4, 6 or 8 words.
+ */
+sjcl.cipher.aes = function (key) {
+  if (!this._tables[0][0][0]) {
+    this._precompute();
+  }
+  
+  var i, j, tmp,
+    encKey, decKey,
+    sbox = this._tables[0][4], decTable = this._tables[1],
+    keyLen = key.length, rcon = 1;
+  
+  if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
+    throw new sjcl.exception.invalid("invalid aes key size");
+  }
+  
+  this._key = [encKey = key.slice(0), decKey = []];
+  
+  // schedule encryption keys
+  for (i = keyLen; i < 4 * keyLen + 28; i++) {
+    tmp = encKey[i-1];
+    
+    // apply sbox
+    if (i%keyLen === 0 || (keyLen === 8 && i%keyLen === 4)) {
+      tmp = sbox[tmp>>>24]<<24 ^ sbox[tmp>>16&255]<<16 ^ sbox[tmp>>8&255]<<8 ^ sbox[tmp&255];
+      
+      // shift rows and add rcon
+      if (i%keyLen === 0) {
+        tmp = tmp<<8 ^ tmp>>>24 ^ rcon<<24;
+        rcon = rcon<<1 ^ (rcon>>7)*283;
+      }
+    }
+    
+    encKey[i] = encKey[i-keyLen] ^ tmp;
+  }
+  
+  // schedule decryption keys
+  for (j = 0; i; j++, i--) {
+    tmp = encKey[j&3 ? i : i - 4];
+    if (i<=4 || j<4) {
+      decKey[j] = tmp;
+    } else {
+      decKey[j] = decTable[0][sbox[tmp>>>24      ]] ^
+                  decTable[1][sbox[tmp>>16  & 255]] ^
+                  decTable[2][sbox[tmp>>8   & 255]] ^
+                  decTable[3][sbox[tmp      & 255]];
+    }
+  }
+};
+
+sjcl.cipher.aes.prototype = {
+  // public
+  /* Something like this might appear here eventually
+  name: "AES",
+  blockSize: 4,
+  keySizes: [4,6,8],
+  */
+  
+  /**
+   * Encrypt an array of 4 big-endian words.
+   * @param {Array} data The plaintext.
+   * @return {Array} The ciphertext.
+   */
+  encrypt:function (data) { return this._crypt(data,0); },
+  
+  /**
+   * Decrypt an array of 4 big-endian words.
+   * @param {Array} data The ciphertext.
+   * @return {Array} The plaintext.
+   */
+  decrypt:function (data) { return this._crypt(data,1); },
+  
+  /**
+   * The expanded S-box and inverse S-box tables.  These will be computed
+   * on the client so that we don't have to send them down the wire.
+   *
+   * There are two tables, _tables[0] is for encryption and
+   * _tables[1] is for decryption.
+   *
+   * The first 4 sub-tables are the expanded S-box with MixColumns.  The
+   * last (_tables[01][4]) is the S-box itself.
+   *
+   * @private
+   */
+  _tables: [[[],[],[],[],[]],[[],[],[],[],[]]],
+
+  /**
+   * Expand the S-box tables.
+   *
+   * @private
+   */
+  _precompute: function () {
+   var encTable = this._tables[0], decTable = this._tables[1],
+       sbox = encTable[4], sboxInv = decTable[4],
+       i, x, xInv, d=[], th=[], x2, x4, x8, s, tEnc, tDec;
+
+    // Compute double and third tables
+   for (i = 0; i < 256; i++) {
+     th[( d[i] = i<<1 ^ (i>>7)*283 )^i]=i;
+   }
+   
+   for (x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
+     // Compute sbox
+     s = xInv ^ xInv<<1 ^ xInv<<2 ^ xInv<<3 ^ xInv<<4;
+     s = s>>8 ^ s&255 ^ 99;
+     sbox[x] = s;
+     sboxInv[s] = x;
+     
+     // Compute MixColumns
+     x8 = d[x4 = d[x2 = d[x]]];
+     tDec = x8*0x1010101 ^ x4*0x10001 ^ x2*0x101 ^ x*0x1010100;
+     tEnc = d[s]*0x101 ^ s*0x1010100;
+     
+     for (i = 0; i < 4; i++) {
+       encTable[i][x] = tEnc = tEnc<<24 ^ tEnc>>>8;
+       decTable[i][s] = tDec = tDec<<24 ^ tDec>>>8;
+     }
+   }
+   
+   // Compactify.  Considerable speedup on Firefox.
+   for (i = 0; i < 5; i++) {
+     encTable[i] = encTable[i].slice(0);
+     decTable[i] = decTable[i].slice(0);
+   }
+  },
+  
+  /**
+   * Encryption and decryption core.
+   * @param {Array} input Four words to be encrypted or decrypted.
+   * @param dir The direction, 0 for encrypt and 1 for decrypt.
+   * @return {Array} The four encrypted or decrypted words.
+   * @private
+   */
+  _crypt:function (input, dir) {
+    if (input.length !== 4) {
+      throw new sjcl.exception.invalid("invalid aes block size");
+    }
+    
+    var key = this._key[dir],
+        // state variables a,b,c,d are loaded with pre-whitened data
+        a = input[0]           ^ key[0],
+        b = input[dir ? 3 : 1] ^ key[1],
+        c = input[2]           ^ key[2],
+        d = input[dir ? 1 : 3] ^ key[3],
+        a2, b2, c2,
+        
+        nInnerRounds = key.length/4 - 2,
+        i,
+        kIndex = 4,
+        out = [0,0,0,0],
+        table = this._tables[dir],
+        
+        // load up the tables
+        t0    = table[0],
+        t1    = table[1],
+        t2    = table[2],
+        t3    = table[3],
+        sbox  = table[4];
+ 
+    // Inner rounds.  Cribbed from OpenSSL.
+    for (i = 0; i < nInnerRounds; i++) {
+      a2 = t0[a>>>24] ^ t1[b>>16 & 255] ^ t2[c>>8 & 255] ^ t3[d & 255] ^ key[kIndex];
+      b2 = t0[b>>>24] ^ t1[c>>16 & 255] ^ t2[d>>8 & 255] ^ t3[a & 255] ^ key[kIndex + 1];
+      c2 = t0[c>>>24] ^ t1[d>>16 & 255] ^ t2[a>>8 & 255] ^ t3[b & 255] ^ key[kIndex + 2];
+      d  = t0[d>>>24] ^ t1[a>>16 & 255] ^ t2[b>>8 & 255] ^ t3[c & 255] ^ key[kIndex + 3];
+      kIndex += 4;
+      a=a2; b=b2; c=c2;
+    }
+        
+    // Last round.
+    for (i = 0; i < 4; i++) {
+      out[dir ? 3&-i : i] =
+        sbox[a>>>24      ]<<24 ^ 
+        sbox[b>>16  & 255]<<16 ^
+        sbox[c>>8   & 255]<<8  ^
+        sbox[d      & 255]     ^
+        key[kIndex++];
+      a2=a; a=b; b=c; c=d; d=a2;
+    }
+    
+    return out;
+  }
+};
+
+/** @fileOverview Arrays of bits, encoded as arrays of Numbers.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * Arrays of bits, encoded as arrays of Numbers.
+ * @namespace
+ * @description
+ * <p>
+ * These objects are the currency accepted by SJCL's crypto functions.
+ * </p>
+ *
+ * <p>
+ * Most of our crypto primitives operate on arrays of 4-byte words internally,
+ * but many of them can take arguments that are not a multiple of 4 bytes.
+ * This library encodes arrays of bits (whose size need not be a multiple of 8
+ * bits) as arrays of 32-bit words.  The bits are packed, big-endian, into an
+ * array of words, 32 bits at a time.  Since the words are double-precision
+ * floating point numbers, they fit some extra data.  We use this (in a private,
+ * possibly-changing manner) to encode the number of bits actually  present
+ * in the last word of the array.
+ * </p>
+ *
+ * <p>
+ * Because bitwise ops clear this out-of-band data, these arrays can be passed
+ * to ciphers like AES which want arrays of words.
+ * </p>
+ */
+sjcl.bitArray = {
+  /**
+   * Array slices in units of bits.
+   * @param {bitArray} a The array to slice.
+   * @param {Number} bstart The offset to the start of the slice, in bits.
+   * @param {Number} bend The offset to the end of the slice, in bits.  If this is undefined,
+   * slice until the end of the array.
+   * @return {bitArray} The requested slice.
+   */
+  bitSlice: function (a, bstart, bend) {
+    a = sjcl.bitArray._shiftRight(a.slice(bstart/32), 32 - (bstart & 31)).slice(1);
+    return (bend === undefined) ? a : sjcl.bitArray.clamp(a, bend-bstart);
+  },
+
+  /**
+   * Extract a number packed into a bit array.
+   * @param {bitArray} a The array to slice.
+   * @param {Number} bstart The offset to the start of the slice, in bits.
+   * @param {Number} blength The length of the number to extract.
+   * @return {Number} The requested slice.
+   */
+  extract: function(a, bstart, blength) {
+    // FIXME: this Math.floor is not necessary at all, but for some reason
+    // seems to suppress a bug in the Chromium JIT.
+    var x, sh = Math.floor((-bstart-blength) & 31);
+    if ((bstart + blength - 1 ^ bstart) & -32) {
+      // it crosses a boundary
+      x = (a[bstart/32|0] << (32 - sh)) ^ (a[bstart/32+1|0] >>> sh);
+    } else {
+      // within a single word
+      x = a[bstart/32|0] >>> sh;
+    }
+    return x & ((1<<blength) - 1);
+  },
+
+  /**
+   * Concatenate two bit arrays.
+   * @param {bitArray} a1 The first array.
+   * @param {bitArray} a2 The second array.
+   * @return {bitArray} The concatenation of a1 and a2.
+   */
+  concat: function (a1, a2) {
+    if (a1.length === 0 || a2.length === 0) {
+      return a1.concat(a2);
+    }
+    
+    var last = a1[a1.length-1], shift = sjcl.bitArray.getPartial(last);
+    if (shift === 32) {
+      return a1.concat(a2);
+    } else {
+      return sjcl.bitArray._shiftRight(a2, shift, last|0, a1.slice(0,a1.length-1));
+    }
+  },
+
+  /**
+   * Find the length of an array of bits.
+   * @param {bitArray} a The array.
+   * @return {Number} The length of a, in bits.
+   */
+  bitLength: function (a) {
+    var l = a.length, x;
+    if (l === 0) { return 0; }
+    x = a[l - 1];
+    return (l-1) * 32 + sjcl.bitArray.getPartial(x);
+  },
+
+  /**
+   * Truncate an array.
+   * @param {bitArray} a The array.
+   * @param {Number} len The length to truncate to, in bits.
+   * @return {bitArray} A new array, truncated to len bits.
+   */
+  clamp: function (a, len) {
+    if (a.length * 32 < len) { return a; }
+    a = a.slice(0, Math.ceil(len / 32));
+    var l = a.length;
+    len = len & 31;
+    if (l > 0 && len) {
+      a[l-1] = sjcl.bitArray.partial(len, a[l-1] & 0x80000000 >> (len-1), 1);
+    }
+    return a;
+  },
+
+  /**
+   * Make a partial word for a bit array.
+   * @param {Number} len The number of bits in the word.
+   * @param {Number} x The bits.
+   * @param {Number} [_end=0] Pass 1 if x has already been shifted to the high side.
+   * @return {Number} The partial word.
+   */
+  partial: function (len, x, _end) {
+    if (len === 32) { return x; }
+    return (_end ? x|0 : x << (32-len)) + len * 0x10000000000;
+  },
+
+  /**
+   * Get the number of bits used by a partial word.
+   * @param {Number} x The partial word.
+   * @return {Number} The number of bits used by the partial word.
+   */
+  getPartial: function (x) {
+    return Math.round(x/0x10000000000) || 32;
+  },
+
+  /**
+   * Compare two arrays for equality in a predictable amount of time.
+   * @param {bitArray} a The first array.
+   * @param {bitArray} b The second array.
+   * @return {boolean} true if a == b; false otherwise.
+   */
+  equal: function (a, b) {
+    if (sjcl.bitArray.bitLength(a) !== sjcl.bitArray.bitLength(b)) {
+      return false;
+    }
+    var x = 0, i;
+    for (i=0; i<a.length; i++) {
+      x |= a[i]^b[i];
+    }
+    return (x === 0);
+  },
+
+  /** Shift an array right.
+   * @param {bitArray} a The array to shift.
+   * @param {Number} shift The number of bits to shift.
+   * @param {Number} [carry=0] A byte to carry in
+   * @param {bitArray} [out=[]] An array to prepend to the output.
+   * @private
+   */
+  _shiftRight: function (a, shift, carry, out) {
+    var i, last2=0, shift2;
+    if (out === undefined) { out = []; }
+    
+    for (; shift >= 32; shift -= 32) {
+      out.push(carry);
+      carry = 0;
+    }
+    if (shift === 0) {
+      return out.concat(a);
+    }
+    
+    for (i=0; i<a.length; i++) {
+      out.push(carry | a[i]>>>shift);
+      carry = a[i] << (32-shift);
+    }
+    last2 = a.length ? a[a.length-1] : 0;
+    shift2 = sjcl.bitArray.getPartial(last2);
+    out.push(sjcl.bitArray.partial(shift+shift2 & 31, (shift + shift2 > 32) ? carry : out.pop(),1));
+    return out;
+  },
+  
+  /** xor a block of 4 words together.
+   * @private
+   */
+  _xor4: function(x,y) {
+    return [x[0]^y[0],x[1]^y[1],x[2]^y[2],x[3]^y[3]];
+  },
+
+  /** byteswap a word array inplace.
+   * (does not handle partial words)
+   * @param {sjcl.bitArray} a word array
+   * @return {sjcl.bitArray} byteswapped array
+   */
+  byteswapM: function(a) {
+    var i, v, m = 0xff00;
+    for (i = 0; i < a.length; ++i) {
+      v = a[i];
+      a[i] = (v >>> 24) | ((v >>> 8) & m) | ((v & m) << 8) | (v << 24);
+    }
+    return a;
+  }
+};
+/** @fileOverview Bit array codec implementations.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * UTF-8 strings
+ * @namespace
+ */
+sjcl.codec.utf8String = {
+  /** Convert from a bitArray to a UTF-8 string. */
+  fromBits: function (arr) {
+    var out = "", bl = sjcl.bitArray.bitLength(arr), i, tmp;
+    for (i=0; i<bl/8; i++) {
+      if ((i&3) === 0) {
+        tmp = arr[i/4];
+      }
+      out += String.fromCharCode(tmp >>> 8 >>> 8 >>> 8);
+      tmp <<= 8;
+    }
+    return decodeURIComponent(escape(out));
+  },
+
+  /** Convert from a UTF-8 string to a bitArray. */
+  toBits: function (str) {
+    str = unescape(encodeURIComponent(str));
+    var out = [], i, tmp=0;
+    for (i=0; i<str.length; i++) {
+      tmp = tmp << 8 | str.charCodeAt(i);
+      if ((i&3) === 3) {
+        out.push(tmp);
+        tmp = 0;
+      }
+    }
+    if (i&3) {
+      out.push(sjcl.bitArray.partial(8*(i&3), tmp));
+    }
+    return out;
+  }
+};
+/** @fileOverview Bit array codec implementations.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * Hexadecimal
+ * @namespace
+ */
+sjcl.codec.hex = {
+  /** Convert from a bitArray to a hex string. */
+  fromBits: function (arr) {
+    var out = "", i;
+    for (i=0; i<arr.length; i++) {
+      out += ((arr[i]|0)+0xF00000000000).toString(16).substr(4);
+    }
+    return out.substr(0, sjcl.bitArray.bitLength(arr)/4);//.replace(/(.{8})/g, "$1 ");
+  },
+  /** Convert from a hex string to a bitArray. */
+  toBits: function (str) {
+    var i, out=[], len;
+    str = str.replace(/\s|0x/g, "");
+    len = str.length;
+    str = str + "00000000";
+    for (i=0; i<str.length; i+=8) {
+      out.push(parseInt(str.substr(i,8),16)^0);
+    }
+    return sjcl.bitArray.clamp(out, len*4);
+  }
+};
+
+/** @fileOverview Bit array codec implementations.
+ *
+ * @author Nils Kenneweg
+ */
+
+/**
+ * Base32 encoding/decoding
+ * @namespace
+ */
+sjcl.codec.base32 = {
+  /** The base32 alphabet.
+   * @private
+   */
+  _chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  _hexChars: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+
+  /* bits in an array */
+  BITS: 32,
+  /* base to encode at (2^x) */
+  BASE: 5,
+  /* bits - base */
+  REMAINING: 27,
+
+  /** Convert from a bitArray to a base32 string. */
+  fromBits: function (arr, _noEquals, _hex) {
+    var BITS = sjcl.codec.base32.BITS, BASE = sjcl.codec.base32.BASE, REMAINING = sjcl.codec.base32.REMAINING;
+    var out = "", i, bits=0, c = sjcl.codec.base32._chars, ta=0, bl = sjcl.bitArray.bitLength(arr);
+
+    if (_hex) {
+      c = sjcl.codec.base32._hexChars;
+    }
+
+    for (i=0; out.length * BASE < bl; ) {
+      out += c.charAt((ta ^ arr[i]>>>bits) >>> REMAINING);
+      if (bits < BASE) {
+        ta = arr[i] << (BASE-bits);
+        bits += REMAINING;
+        i++;
+      } else {
+        ta <<= BASE;
+        bits -= BASE;
+      }
+    }
+    while ((out.length & 7) && !_noEquals) { out += "="; }
+
+    return out;
+  },
+
+  /** Convert from a base32 string to a bitArray */
+  toBits: function(str, _hex) {
+    str = str.replace(/\s|=/g,'').toUpperCase();
+    var BITS = sjcl.codec.base32.BITS, BASE = sjcl.codec.base32.BASE, REMAINING = sjcl.codec.base32.REMAINING;
+    var out = [], i, bits=0, c = sjcl.codec.base32._chars, ta=0, x, format="base32";
+
+    if (_hex) {
+      c = sjcl.codec.base32._hexChars;
+      format = "base32hex";
+    }
+
+    for (i=0; i<str.length; i++) {
+      x = c.indexOf(str.charAt(i));
+      if (x < 0) {
+        // Invalid character, try hex format
+        if (!_hex) {
+          try {
+            return sjcl.codec.base32hex.toBits(str);
+          }
+          catch (e) {}
+        }
+        throw new sjcl.exception.invalid("this isn't " + format + "!");
+      }
+      if (bits > REMAINING) {
+        bits -= REMAINING;
+        out.push(ta ^ x>>>bits);
+        ta  = x << (BITS-bits);
+      } else {
+        bits += BASE;
+        ta ^= x << (BITS-bits);
+      }
+    }
+    if (bits&56) {
+      out.push(sjcl.bitArray.partial(bits&56, ta, 1));
+    }
+    return out;
+  }
+};
+
+sjcl.codec.base32hex = {
+  fromBits: function (arr, _noEquals) { return sjcl.codec.base32.fromBits(arr,_noEquals,1); },
+  toBits: function (str) { return sjcl.codec.base32.toBits(str,1); }
+};
+/** @fileOverview Bit array codec implementations.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * Base64 encoding/decoding 
+ * @namespace
+ */
+sjcl.codec.base64 = {
+  /** The base64 alphabet.
+   * @private
+   */
+  _chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  
+  /** Convert from a bitArray to a base64 string. */
+  fromBits: function (arr, _noEquals, _url) {
+    var out = "", i, bits=0, c = sjcl.codec.base64._chars, ta=0, bl = sjcl.bitArray.bitLength(arr);
+    if (_url) {
+      c = c.substr(0,62) + '-_';
+    }
+    for (i=0; out.length * 6 < bl; ) {
+      out += c.charAt((ta ^ arr[i]>>>bits) >>> 26);
+      if (bits < 6) {
+        ta = arr[i] << (6-bits);
+        bits += 26;
+        i++;
+      } else {
+        ta <<= 6;
+        bits -= 6;
+      }
+    }
+    while ((out.length & 3) && !_noEquals) { out += "="; }
+    return out;
+  },
+  
+  /** Convert from a base64 string to a bitArray */
+  toBits: function(str, _url) {
+    str = str.replace(/\s|=/g,'');
+    var out = [], i, bits=0, c = sjcl.codec.base64._chars, ta=0, x;
+    if (_url) {
+      c = c.substr(0,62) + '-_';
+    }
+    for (i=0; i<str.length; i++) {
+      x = c.indexOf(str.charAt(i));
+      if (x < 0) {
+        throw new sjcl.exception.invalid("this isn't base64!");
+      }
+      if (bits > 26) {
+        bits -= 26;
+        out.push(ta ^ x>>>bits);
+        ta  = x << (32-bits);
+      } else {
+        bits += 6;
+        ta ^= x << (32-bits);
+      }
+    }
+    if (bits&56) {
+      out.push(sjcl.bitArray.partial(bits&56, ta, 1));
+    }
+    return out;
+  }
+};
+
+sjcl.codec.base64url = {
+  fromBits: function (arr) { return sjcl.codec.base64.fromBits(arr,1,1); },
+  toBits: function (str) { return sjcl.codec.base64.toBits(str,1); }
+};
+/** @fileOverview Bit array codec implementations.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * Arrays of bytes
+ * @namespace
+ */
+sjcl.codec.bytes = {
+  /** Convert from a bitArray to an array of bytes. */
+  fromBits: function (arr) {
+    var out = [], bl = sjcl.bitArray.bitLength(arr), i, tmp;
+    for (i=0; i<bl/8; i++) {
+      if ((i&3) === 0) {
+        tmp = arr[i/4];
+      }
+      out.push(tmp >>> 24);
+      tmp <<= 8;
+    }
+    return out;
+  },
+  /** Convert from an array of bytes to a bitArray. */
+  toBits: function (bytes) {
+    var out = [], i, tmp=0;
+    for (i=0; i<bytes.length; i++) {
+      tmp = tmp << 8 | bytes[i];
+      if ((i&3) === 3) {
+        out.push(tmp);
+        tmp = 0;
+      }
+    }
+    if (i&3) {
+      out.push(sjcl.bitArray.partial(8*(i&3), tmp));
+    }
+    return out;
+  }
+};
+/** @fileOverview Javascript SHA-256 implementation.
+ *
+ * An older version of this implementation is available in the public
+ * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,
+ * Stanford University 2008-2010 and BSD-licensed for liability
+ * reasons.
+ *
+ * Special thanks to Aldo Cortesi for pointing out several bugs in
+ * this code.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * Context for a SHA-256 operation in progress.
+ * @constructor
+ */
+sjcl.hash.sha256 = function (hash) {
+  if (!this._key[0]) { this._precompute(); }
+  if (hash) {
+    this._h = hash._h.slice(0);
+    this._buffer = hash._buffer.slice(0);
+    this._length = hash._length;
+  } else {
+    this.reset();
+  }
+};
+
+/**
+ * Hash a string or an array of words.
+ * @static
+ * @param {bitArray|String} data the data to hash.
+ * @return {bitArray} The hash value, an array of 16 big-endian words.
+ */
+sjcl.hash.sha256.hash = function (data) {
+  return (new sjcl.hash.sha256()).update(data).finalize();
+};
+
+sjcl.hash.sha256.prototype = {
+  /**
+   * The hash's block size, in bits.
+   * @constant
+   */
+  blockSize: 512,
+   
+  /**
+   * Reset the hash state.
+   * @return this
+   */
+  reset:function () {
+    this._h = this._init.slice(0);
+    this._buffer = [];
+    this._length = 0;
+    return this;
+  },
+  
+  /**
+   * Input several words to the hash.
+   * @param {bitArray|String} data the data to hash.
+   * @return this
+   */
+  update: function (data) {
+    if (typeof data === "string") {
+      data = sjcl.codec.utf8String.toBits(data);
+    }
+    var i, b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
+        ol = this._length,
+        nl = this._length = ol + sjcl.bitArray.bitLength(data);
+    if (nl > 9007199254740991){
+      throw new sjcl.exception.invalid("Cannot hash more than 2^53 - 1 bits");
+    }
+
+    if (typeof Uint32Array !== 'undefined') {
+	var c = new Uint32Array(b);
+    	var j = 0;
+    	for (i = 512+ol - ((512+ol) & 511); i <= nl; i+= 512) {
+      	    this._block(c.subarray(16 * j, 16 * (j+1)));
+      	    j += 1;
+    	}
+    	b.splice(0, 16 * j);
+    } else {
+	for (i = 512+ol - ((512+ol) & 511); i <= nl; i+= 512) {
+      	    this._block(b.splice(0,16));
+      	}
+    }
+    return this;
+  },
+  
+  /**
+   * Complete hashing and output the hash value.
+   * @return {bitArray} The hash value, an array of 8 big-endian words.
+   */
+  finalize:function () {
+    var i, b = this._buffer, h = this._h;
+
+    // Round out and push the buffer
+    b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1,1)]);
+    
+    // Round out the buffer to a multiple of 16 words, less the 2 length words.
+    for (i = b.length + 2; i & 15; i++) {
+      b.push(0);
+    }
+    
+    // append the length
+    b.push(Math.floor(this._length / 0x100000000));
+    b.push(this._length | 0);
+
+    while (b.length) {
+      this._block(b.splice(0,16));
+    }
+
+    this.reset();
+    return h;
+  },
+
+  /**
+   * The SHA-256 initialization vector, to be precomputed.
+   * @private
+   */
+  _init:[],
+  /*
+  _init:[0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19],
+  */
+  
+  /**
+   * The SHA-256 hash key, to be precomputed.
+   * @private
+   */
+  _key:[],
+  /*
+  _key:
+    [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2],
+  */
+
+
+  /**
+   * Function to precompute _init and _key.
+   * @private
+   */
+  _precompute: function () {
+    var i = 0, prime = 2, factor, isPrime;
+
+    function frac(x) { return (x-Math.floor(x)) * 0x100000000 | 0; }
+
+    for (; i<64; prime++) {
+      isPrime = true;
+      for (factor=2; factor*factor <= prime; factor++) {
+        if (prime % factor === 0) {
+          isPrime = false;
+          break;
+        }
+      }
+      if (isPrime) {
+        if (i<8) {
+          this._init[i] = frac(Math.pow(prime, 1/2));
+        }
+        this._key[i] = frac(Math.pow(prime, 1/3));
+        i++;
+      }
+    }
+  },
+  
+  /**
+   * Perform one cycle of SHA-256.
+   * @param {Uint32Array|bitArray} w one block of words.
+   * @private
+   */
+  _block:function (w) {  
+    var i, tmp, a, b,
+      h = this._h,
+      k = this._key,
+      h0 = h[0], h1 = h[1], h2 = h[2], h3 = h[3],
+      h4 = h[4], h5 = h[5], h6 = h[6], h7 = h[7];
+
+    /* Rationale for placement of |0 :
+     * If a value can overflow is original 32 bits by a factor of more than a few
+     * million (2^23 ish), there is a possibility that it might overflow the
+     * 53-bit mantissa and lose precision.
+     *
+     * To avoid this, we clamp back to 32 bits by |'ing with 0 on any value that
+     * propagates around the loop, and on the hash state h[].  I don't believe
+     * that the clamps on h4 and on h0 are strictly necessary, but it's close
+     * (for h4 anyway), and better safe than sorry.
+     *
+     * The clamps on h[] are necessary for the output to be correct even in the
+     * common case and for short inputs.
+     */
+    for (i=0; i<64; i++) {
+      // load up the input word for this round
+      if (i<16) {
+        tmp = w[i];
+      } else {
+        a   = w[(i+1 ) & 15];
+        b   = w[(i+14) & 15];
+        tmp = w[i&15] = ((a>>>7  ^ a>>>18 ^ a>>>3  ^ a<<25 ^ a<<14) + 
+                         (b>>>17 ^ b>>>19 ^ b>>>10 ^ b<<15 ^ b<<13) +
+                         w[i&15] + w[(i+9) & 15]) | 0;
+      }
+      
+      tmp = (tmp + h7 + (h4>>>6 ^ h4>>>11 ^ h4>>>25 ^ h4<<26 ^ h4<<21 ^ h4<<7) +  (h6 ^ h4&(h5^h6)) + k[i]); // | 0;
+      
+      // shift register
+      h7 = h6; h6 = h5; h5 = h4;
+      h4 = h3 + tmp | 0;
+      h3 = h2; h2 = h1; h1 = h0;
+
+      h0 = (tmp +  ((h1&h2) ^ (h3&(h1^h2))) + (h1>>>2 ^ h1>>>13 ^ h1>>>22 ^ h1<<30 ^ h1<<19 ^ h1<<10)) | 0;
+    }
+
+    h[0] = h[0]+h0 | 0;
+    h[1] = h[1]+h1 | 0;
+    h[2] = h[2]+h2 | 0;
+    h[3] = h[3]+h3 | 0;
+    h[4] = h[4]+h4 | 0;
+    h[5] = h[5]+h5 | 0;
+    h[6] = h[6]+h6 | 0;
+    h[7] = h[7]+h7 | 0;
+  }
+};
+
+
+/** @fileOverview CCM mode implementation.
+ *
+ * Special thanks to Roy Nicholson for pointing out a bug in our
+ * implementation.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * CTR mode with CBC MAC.
+ * @namespace
+ */
+sjcl.mode.ccm = {
+  /** The name of the mode.
+   * @constant
+   */
+  name: "ccm",
+  
+  _progressListeners: [],
+
+  listenProgress: function (cb) {
+    sjcl.mode.ccm._progressListeners.push(cb);
+  },
+
+  unListenProgress: function (cb) {
+    var index = sjcl.mode.ccm._progressListeners.indexOf(cb);
+    if (index > -1) {
+      sjcl.mode.ccm._progressListeners.splice(index, 1);
+    }
+  },
+
+  _callProgressListener: function (val) {
+    var p = sjcl.mode.ccm._progressListeners.slice(), i;
+
+    for (i = 0; i < p.length; i += 1) {
+      p[i](val);
+    }
+  },
+
+  /** Encrypt in CCM mode.
+   * @static
+   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
+   * @param {bitArray} plaintext The plaintext data.
+   * @param {bitArray} iv The initialization value.
+   * @param {bitArray} [adata=[]] The authenticated data.
+   * @param {Number} [tlen=64] the desired tag length, in bits.
+   * @return {bitArray} The encrypted data, an array of bytes.
+   */
+  encrypt: function(prf, plaintext, iv, adata, tlen) {
+    var L, out = plaintext.slice(0), tag, w=sjcl.bitArray, ivl = w.bitLength(iv) / 8, ol = w.bitLength(out) / 8;
+    tlen = tlen || 64;
+    adata = adata || [];
+    
+    if (ivl < 7) {
+      throw new sjcl.exception.invalid("ccm: iv must be at least 7 bytes");
+    }
+    
+    // compute the length of the length
+    for (L=2; L<4 && ol >>> 8*L; L++) {}
+    if (L < 15 - ivl) { L = 15-ivl; }
+    iv = w.clamp(iv,8*(15-L));
+    
+    // compute the tag
+    tag = sjcl.mode.ccm._computeTag(prf, plaintext, iv, adata, tlen, L);
+    
+    // encrypt
+    out = sjcl.mode.ccm._ctrMode(prf, out, iv, tag, tlen, L);
+    
+    return w.concat(out.data, out.tag);
+  },
+  
+  /** Decrypt in CCM mode.
+   * @static
+   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
+   * @param {bitArray} ciphertext The ciphertext data.
+   * @param {bitArray} iv The initialization value.
+   * @param {bitArray} [adata=[]] adata The authenticated data.
+   * @param {Number} [tlen=64] tlen the desired tag length, in bits.
+   * @return {bitArray} The decrypted data.
+   */
+  decrypt: function(prf, ciphertext, iv, adata, tlen) {
+    tlen = tlen || 64;
+    adata = adata || [];
+    var L,
+        w=sjcl.bitArray,
+        ivl = w.bitLength(iv) / 8,
+        ol = w.bitLength(ciphertext), 
+        out = w.clamp(ciphertext, ol - tlen),
+        tag = w.bitSlice(ciphertext, ol - tlen), tag2;
+    
+
+    ol = (ol - tlen) / 8;
+        
+    if (ivl < 7) {
+      throw new sjcl.exception.invalid("ccm: iv must be at least 7 bytes");
+    }
+    
+    // compute the length of the length
+    for (L=2; L<4 && ol >>> 8*L; L++) {}
+    if (L < 15 - ivl) { L = 15-ivl; }
+    iv = w.clamp(iv,8*(15-L));
+    
+    // decrypt
+    out = sjcl.mode.ccm._ctrMode(prf, out, iv, tag, tlen, L);
+    
+    // check the tag
+    tag2 = sjcl.mode.ccm._computeTag(prf, out.data, iv, adata, tlen, L);
+    if (!w.equal(out.tag, tag2)) {
+      throw new sjcl.exception.corrupt("ccm: tag doesn't match");
+    }
+    
+    return out.data;
+  },
+
+  _macAdditionalData: function (prf, adata, iv, tlen, ol, L) {
+    var mac, tmp, i, macData = [], w=sjcl.bitArray, xor = w._xor4;
+
+    // mac the flags
+    mac = [w.partial(8, (adata.length ? 1<<6 : 0) | (tlen-2) << 2 | L-1)];
+
+    // mac the iv and length
+    mac = w.concat(mac, iv);
+    mac[3] |= ol;
+    mac = prf.encrypt(mac);
+  
+    if (adata.length) {
+      // mac the associated data.  start with its length...
+      tmp = w.bitLength(adata)/8;
+      if (tmp <= 0xFEFF) {
+        macData = [w.partial(16, tmp)];
+      } else if (tmp <= 0xFFFFFFFF) {
+        macData = w.concat([w.partial(16,0xFFFE)], [tmp]);
+      } // else ...
+    
+      // mac the data itself
+      macData = w.concat(macData, adata);
+      for (i=0; i<macData.length; i += 4) {
+        mac = prf.encrypt(xor(mac, macData.slice(i,i+4).concat([0,0,0])));
+      }
+    }
+
+    return mac;
+  },
+
+  /* Compute the (unencrypted) authentication tag, according to the CCM specification
+   * @param {Object} prf The pseudorandom function.
+   * @param {bitArray} plaintext The plaintext data.
+   * @param {bitArray} iv The initialization value.
+   * @param {bitArray} adata The authenticated data.
+   * @param {Number} tlen the desired tag length, in bits.
+   * @return {bitArray} The tag, but not yet encrypted.
+   * @private
+   */
+  _computeTag: function(prf, plaintext, iv, adata, tlen, L) {
+    // compute B[0]
+    var mac, i, w=sjcl.bitArray, xor = w._xor4;
+
+    tlen /= 8;
+  
+    // check tag length and message length
+    if (tlen % 2 || tlen < 4 || tlen > 16) {
+      throw new sjcl.exception.invalid("ccm: invalid tag length");
+    }
+  
+    if (adata.length > 0xFFFFFFFF || plaintext.length > 0xFFFFFFFF) {
+      // I don't want to deal with extracting high words from doubles.
+      throw new sjcl.exception.bug("ccm: can't deal with 4GiB or more data");
+    }
+
+    mac = sjcl.mode.ccm._macAdditionalData(prf, adata, iv, tlen, w.bitLength(plaintext)/8, L);
+
+    // mac the plaintext
+    for (i=0; i<plaintext.length; i+=4) {
+      mac = prf.encrypt(xor(mac, plaintext.slice(i,i+4).concat([0,0,0])));
+    }
+
+    return w.clamp(mac, tlen * 8);
+  },
+
+  /** CCM CTR mode.
+   * Encrypt or decrypt data and tag with the prf in CCM-style CTR mode.
+   * May mutate its arguments.
+   * @param {Object} prf The PRF.
+   * @param {bitArray} data The data to be encrypted or decrypted.
+   * @param {bitArray} iv The initialization vector.
+   * @param {bitArray} tag The authentication tag.
+   * @param {Number} tlen The length of th etag, in bits.
+   * @param {Number} L The CCM L value.
+   * @return {Object} An object with data and tag, the en/decryption of data and tag values.
+   * @private
+   */
+  _ctrMode: function(prf, data, iv, tag, tlen, L) {
+    var enc, i, w=sjcl.bitArray, xor = w._xor4, ctr, l = data.length, bl=w.bitLength(data), n = l/50, p = n;
+
+    // start the ctr
+    ctr = w.concat([w.partial(8,L-1)],iv).concat([0,0,0]).slice(0,4);
+    
+    // en/decrypt the tag
+    tag = w.bitSlice(xor(tag,prf.encrypt(ctr)), 0, tlen);
+  
+    // en/decrypt the data
+    if (!l) { return {tag:tag, data:[]}; }
+    
+    for (i=0; i<l; i+=4) {
+      if (i > n) {
+        sjcl.mode.ccm._callProgressListener(i/l);
+        n += p;
+      }
+      ctr[3]++;
+      enc = prf.encrypt(ctr);
+      data[i]   ^= enc[0];
+      data[i+1] ^= enc[1];
+      data[i+2] ^= enc[2];
+      data[i+3] ^= enc[3];
+    }
+    return { tag:tag, data:w.clamp(data,bl) };
+  }
+};
+/** @fileOverview OCB 2.0 implementation
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/** 
+ * Phil Rogaway's Offset CodeBook mode, version 2.0.
+ * May be covered by US and international patents.
+ *
+ * @namespace
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+sjcl.mode.ocb2 = {
+  /** The name of the mode.
+   * @constant
+   */
+  name: "ocb2",
+  
+  /** Encrypt in OCB mode, version 2.0.
+   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
+   * @param {bitArray} plaintext The plaintext data.
+   * @param {bitArray} iv The initialization value.
+   * @param {bitArray} [adata=[]] The authenticated data.
+   * @param {Number} [tlen=64] the desired tag length, in bits.
+   * @param {boolean} [premac=false] true if the authentication data is pre-macced with PMAC.
+   * @return The encrypted data, an array of bytes.
+   * @throws {sjcl.exception.invalid} if the IV isn't exactly 128 bits.
+   */
+  encrypt: function(prp, plaintext, iv, adata, tlen, premac) {
+    if (sjcl.bitArray.bitLength(iv) !== 128) {
+      throw new sjcl.exception.invalid("ocb iv must be 128 bits");
+    }
+    var i,
+        times2 = sjcl.mode.ocb2._times2,
+        w = sjcl.bitArray,
+        xor = w._xor4,
+        checksum = [0,0,0,0],
+        delta = times2(prp.encrypt(iv)),
+        bi, bl,
+        output = [],
+        pad;
+        
+    adata = adata || [];
+    tlen  = tlen || 64;
+  
+    for (i=0; i+4 < plaintext.length; i+=4) {
+      /* Encrypt a non-final block */
+      bi = plaintext.slice(i,i+4);
+      checksum = xor(checksum, bi);
+      output = output.concat(xor(delta,prp.encrypt(xor(delta, bi))));
+      delta = times2(delta);
+    }
+    
+    /* Chop out the final block */
+    bi = plaintext.slice(i);
+    bl = w.bitLength(bi);
+    pad = prp.encrypt(xor(delta,[0,0,0,bl]));
+    bi = w.clamp(xor(bi.concat([0,0,0]),pad), bl);
+    
+    /* Checksum the final block, and finalize the checksum */
+    checksum = xor(checksum,xor(bi.concat([0,0,0]),pad));
+    checksum = prp.encrypt(xor(checksum,xor(delta,times2(delta))));
+    
+    /* MAC the header */
+    if (adata.length) {
+      checksum = xor(checksum, premac ? adata : sjcl.mode.ocb2.pmac(prp, adata));
+    }
+    
+    return output.concat(w.concat(bi, w.clamp(checksum, tlen)));
+  },
+  
+  /** Decrypt in OCB mode.
+   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
+   * @param {bitArray} ciphertext The ciphertext data.
+   * @param {bitArray} iv The initialization value.
+   * @param {bitArray} [adata=[]] The authenticated data.
+   * @param {Number} [tlen=64] the desired tag length, in bits.
+   * @param {boolean} [premac=false] true if the authentication data is pre-macced with PMAC.
+   * @return The decrypted data, an array of bytes.
+   * @throws {sjcl.exception.invalid} if the IV isn't exactly 128 bits.
+   * @throws {sjcl.exception.corrupt} if if the message is corrupt.
+   */
+  decrypt: function(prp, ciphertext, iv, adata, tlen, premac) {
+    if (sjcl.bitArray.bitLength(iv) !== 128) {
+      throw new sjcl.exception.invalid("ocb iv must be 128 bits");
+    }
+    tlen  = tlen || 64;
+    var i,
+        times2 = sjcl.mode.ocb2._times2,
+        w = sjcl.bitArray,
+        xor = w._xor4,
+        checksum = [0,0,0,0],
+        delta = times2(prp.encrypt(iv)),
+        bi, bl,
+        len = sjcl.bitArray.bitLength(ciphertext) - tlen,
+        output = [],
+        pad;
+        
+    adata = adata || [];
+  
+    for (i=0; i+4 < len/32; i+=4) {
+      /* Decrypt a non-final block */
+      bi = xor(delta, prp.decrypt(xor(delta, ciphertext.slice(i,i+4))));
+      checksum = xor(checksum, bi);
+      output = output.concat(bi);
+      delta = times2(delta);
+    }
+    
+    /* Chop out and decrypt the final block */
+    bl = len-i*32;
+    pad = prp.encrypt(xor(delta,[0,0,0,bl]));
+    bi = xor(pad, w.clamp(ciphertext.slice(i),bl).concat([0,0,0]));
+    
+    /* Checksum the final block, and finalize the checksum */
+    checksum = xor(checksum, bi);
+    checksum = prp.encrypt(xor(checksum, xor(delta, times2(delta))));
+    
+    /* MAC the header */
+    if (adata.length) {
+      checksum = xor(checksum, premac ? adata : sjcl.mode.ocb2.pmac(prp, adata));
+    }
+    
+    if (!w.equal(w.clamp(checksum, tlen), w.bitSlice(ciphertext, len))) {
+      throw new sjcl.exception.corrupt("ocb: tag doesn't match");
+    }
+    
+    return output.concat(w.clamp(bi,bl));
+  },
+  
+  /** PMAC authentication for OCB associated data.
+   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
+   * @param {bitArray} adata The authenticated data.
+   */
+  pmac: function(prp, adata) {
+    var i,
+        times2 = sjcl.mode.ocb2._times2,
+        w = sjcl.bitArray,
+        xor = w._xor4,
+        checksum = [0,0,0,0],
+        delta = prp.encrypt([0,0,0,0]),
+        bi;
+        
+    delta = xor(delta,times2(times2(delta)));
+ 
+    for (i=0; i+4<adata.length; i+=4) {
+      delta = times2(delta);
+      checksum = xor(checksum, prp.encrypt(xor(delta, adata.slice(i,i+4))));
+    }
+    
+    bi = adata.slice(i);
+    if (w.bitLength(bi) < 128) {
+      delta = xor(delta,times2(delta));
+      bi = w.concat(bi,[0x80000000|0,0,0,0]);
+    }
+    checksum = xor(checksum, bi);
+    return prp.encrypt(xor(times2(xor(delta,times2(delta))), checksum));
+  },
+  
+  /** Double a block of words, OCB style.
+   * @private
+   */
+  _times2: function(x) {
+    return [x[0]<<1 ^ x[1]>>>31,
+            x[1]<<1 ^ x[2]>>>31,
+            x[2]<<1 ^ x[3]>>>31,
+            x[3]<<1 ^ (x[0]>>>31)*0x87];
+  }
+};
+/** @fileOverview GCM mode implementation.
+ *
+ * @author Juho Vähä-Herttua
+ */
+
+/**
+ * Galois/Counter mode.
+ * @namespace
+ */ 
+sjcl.mode.gcm = {
+  /**
+   * The name of the mode.
+   * @constant
+   */
+  name: "gcm",
+  
+  /** Encrypt in GCM mode.
+   * @static
+   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
+   * @param {bitArray} plaintext The plaintext data.
+   * @param {bitArray} iv The initialization value.
+   * @param {bitArray} [adata=[]] The authenticated data.
+   * @param {Number} [tlen=128] The desired tag length, in bits.
+   * @return {bitArray} The encrypted data, an array of bytes.
+   */
+  encrypt: function (prf, plaintext, iv, adata, tlen) {
+    var out, data = plaintext.slice(0), w=sjcl.bitArray;
+    tlen = tlen || 128;
+    adata = adata || [];
+
+    // encrypt and tag
+    out = sjcl.mode.gcm._ctrMode(true, prf, data, adata, iv, tlen);
+
+    return w.concat(out.data, out.tag);
+  },
+  
+  /** Decrypt in GCM mode.
+   * @static
+   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
+   * @param {bitArray} ciphertext The ciphertext data.
+   * @param {bitArray} iv The initialization value.
+   * @param {bitArray} [adata=[]] The authenticated data.
+   * @param {Number} [tlen=128] The desired tag length, in bits.
+   * @return {bitArray} The decrypted data.
+   */
+  decrypt: function (prf, ciphertext, iv, adata, tlen) {
+    var out, data = ciphertext.slice(0), tag, w=sjcl.bitArray, l=w.bitLength(data);
+    tlen = tlen || 128;
+    adata = adata || [];
+
+    // Slice tag out of data
+    if (tlen <= l) {
+      tag = w.bitSlice(data, l-tlen);
+      data = w.bitSlice(data, 0, l-tlen);
+    } else {
+      tag = data;
+      data = [];
+    }
+
+    // decrypt and tag
+    out = sjcl.mode.gcm._ctrMode(false, prf, data, adata, iv, tlen);
+
+    if (!w.equal(out.tag, tag)) {
+      throw new sjcl.exception.corrupt("gcm: tag doesn't match");
+    }
+    return out.data;
+  },
+
+  /* Compute the galois multiplication of X and Y
+   * @private
+   */
+  _galoisMultiply: function (x, y) {
+    var i, j, xi, Zi, Vi, lsb_Vi, w=sjcl.bitArray, xor=w._xor4;
+
+    Zi = [0,0,0,0];
+    Vi = y.slice(0);
+
+    // Block size is 128 bits, run 128 times to get Z_128
+    for (i=0; i<128; i++) {
+      xi = (x[Math.floor(i/32)] & (1 << (31-i%32))) !== 0;
+      if (xi) {
+        // Z_i+1 = Z_i ^ V_i
+        Zi = xor(Zi, Vi);
+      }
+
+      // Store the value of LSB(V_i)
+      lsb_Vi = (Vi[3] & 1) !== 0;
+
+      // V_i+1 = V_i >> 1
+      for (j=3; j>0; j--) {
+        Vi[j] = (Vi[j] >>> 1) | ((Vi[j-1]&1) << 31);
+      }
+      Vi[0] = Vi[0] >>> 1;
+
+      // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R
+      if (lsb_Vi) {
+        Vi[0] = Vi[0] ^ (0xe1 << 24);
+      }
+    }
+    return Zi;
+  },
+
+  _ghash: function(H, Y0, data) {
+    var Yi, i, l = data.length;
+
+    Yi = Y0.slice(0);
+    for (i=0; i<l; i+=4) {
+      Yi[0] ^= 0xffffffff&data[i];
+      Yi[1] ^= 0xffffffff&data[i+1];
+      Yi[2] ^= 0xffffffff&data[i+2];
+      Yi[3] ^= 0xffffffff&data[i+3];
+      Yi = sjcl.mode.gcm._galoisMultiply(Yi, H);
+    }
+    return Yi;
+  },
+
+  /** GCM CTR mode.
+   * Encrypt or decrypt data and tag with the prf in GCM-style CTR mode.
+   * @param {Boolean} encrypt True if encrypt, false if decrypt.
+   * @param {Object} prf The PRF.
+   * @param {bitArray} data The data to be encrypted or decrypted.
+   * @param {bitArray} iv The initialization vector.
+   * @param {bitArray} adata The associated data to be tagged.
+   * @param {Number} tlen The length of the tag, in bits.
+   */
+  _ctrMode: function(encrypt, prf, data, adata, iv, tlen) {
+    var H, J0, S0, enc, i, ctr, tag, last, l, bl, abl, ivbl, w=sjcl.bitArray;
+
+    // Calculate data lengths
+    l = data.length;
+    bl = w.bitLength(data);
+    abl = w.bitLength(adata);
+    ivbl = w.bitLength(iv);
+
+    // Calculate the parameters
+    H = prf.encrypt([0,0,0,0]);
+    if (ivbl === 96) {
+      J0 = iv.slice(0);
+      J0 = w.concat(J0, [1]);
+    } else {
+      J0 = sjcl.mode.gcm._ghash(H, [0,0,0,0], iv);
+      J0 = sjcl.mode.gcm._ghash(H, J0, [0,0,Math.floor(ivbl/0x100000000),ivbl&0xffffffff]);
+    }
+    S0 = sjcl.mode.gcm._ghash(H, [0,0,0,0], adata);
+
+    // Initialize ctr and tag
+    ctr = J0.slice(0);
+    tag = S0.slice(0);
+
+    // If decrypting, calculate hash
+    if (!encrypt) {
+      tag = sjcl.mode.gcm._ghash(H, S0, data);
+    }
+
+    // Encrypt all the data
+    for (i=0; i<l; i+=4) {
+       ctr[3]++;
+       enc = prf.encrypt(ctr);
+       data[i]   ^= enc[0];
+       data[i+1] ^= enc[1];
+       data[i+2] ^= enc[2];
+       data[i+3] ^= enc[3];
+    }
+    data = w.clamp(data, bl);
+
+    // If encrypting, calculate hash
+    if (encrypt) {
+      tag = sjcl.mode.gcm._ghash(H, S0, data);
+    }
+
+    // Calculate last block from bit lengths, ugly because bitwise operations are 32-bit
+    last = [
+      Math.floor(abl/0x100000000), abl&0xffffffff,
+      Math.floor(bl/0x100000000), bl&0xffffffff
+    ];
+
+    // Calculate the final tag block
+    tag = sjcl.mode.gcm._ghash(H, tag, last);
+    enc = prf.encrypt(J0);
+    tag[0] ^= enc[0];
+    tag[1] ^= enc[1];
+    tag[2] ^= enc[2];
+    tag[3] ^= enc[3];
+
+    return { tag:w.bitSlice(tag, 0, tlen), data:data };
+  }
+};
+/** @fileOverview HMAC implementation.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/** HMAC with the specified hash function.
+ * @constructor
+ * @param {bitArray} key the key for HMAC.
+ * @param {Object} [Hash=sjcl.hash.sha256] The hash function to use.
+ */
+sjcl.misc.hmac = function (key, Hash) {
+  this._hash = Hash = Hash || sjcl.hash.sha256;
+  var exKey = [[],[]], i,
+      bs = Hash.prototype.blockSize / 32;
+  this._baseHash = [new Hash(), new Hash()];
+
+  if (key.length > bs) {
+    key = Hash.hash(key);
+  }
+  
+  for (i=0; i<bs; i++) {
+    exKey[0][i] = key[i]^0x36363636;
+    exKey[1][i] = key[i]^0x5C5C5C5C;
+  }
+  
+  this._baseHash[0].update(exKey[0]);
+  this._baseHash[1].update(exKey[1]);
+  this._resultHash = new Hash(this._baseHash[0]);
+};
+
+/** HMAC with the specified hash function.  Also called encrypt since it's a prf.
+ * @param {bitArray|String} data The data to mac.
+ */
+sjcl.misc.hmac.prototype.encrypt = sjcl.misc.hmac.prototype.mac = function (data) {
+  if (!this._updated) {
+    this.update(data);
+    return this.digest(data);
+  } else {
+    throw new sjcl.exception.invalid("encrypt on already updated hmac called!");
+  }
+};
+
+sjcl.misc.hmac.prototype.reset = function () {
+  this._resultHash = new this._hash(this._baseHash[0]);
+  this._updated = false;
+};
+
+sjcl.misc.hmac.prototype.update = function (data) {
+  this._updated = true;
+  this._resultHash.update(data);
+};
+
+sjcl.misc.hmac.prototype.digest = function () {
+  var w = this._resultHash.finalize(), result = new (this._hash)(this._baseHash[1]).update(w).finalize();
+
+  this.reset();
+
+  return result;
+};
+/** @fileOverview Password-based key-derivation function, version 2.0.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/** Password-Based Key-Derivation Function, version 2.0.
+ *
+ * Generate keys from passwords using PBKDF2-HMAC-SHA256.
+ *
+ * This is the method specified by RSA's PKCS #5 standard.
+ *
+ * @param {bitArray|String} password  The password.
+ * @param {bitArray|String} salt The salt.  Should have lots of entropy.
+ * @param {Number} [count=1000] The number of iterations.  Higher numbers make the function slower but more secure.
+ * @param {Number} [length] The length of the derived key.  Defaults to the
+                            output size of the hash function.
+ * @param {Object} [Prff=sjcl.misc.hmac] The pseudorandom function family.
+ * @return {bitArray} the derived key.
+ */
+sjcl.misc.pbkdf2 = function (password, salt, count, length, Prff) {
+  count = count || 10000;
+  
+  if (length < 0 || count < 0) {
+    throw new sjcl.exception.invalid("invalid params to pbkdf2");
+  }
+  
+  if (typeof password === "string") {
+    password = sjcl.codec.utf8String.toBits(password);
+  }
+  
+  if (typeof salt === "string") {
+    salt = sjcl.codec.utf8String.toBits(salt);
+  }
+  
+  Prff = Prff || sjcl.misc.hmac;
+  
+  var prf = new Prff(password),
+      u, ui, i, j, k, out = [], b = sjcl.bitArray;
+
+  for (k = 1; 32 * out.length < (length || 1); k++) {
+    u = ui = prf.encrypt(b.concat(salt,[k]));
+    
+    for (i=1; i<count; i++) {
+      ui = prf.encrypt(ui);
+      for (j=0; j<ui.length; j++) {
+        u[j] ^= ui[j];
+      }
+    }
+    
+    out = out.concat(u);
+  }
+
+  if (length) { out = b.clamp(out, length); }
+
+  return out;
+};
+/** @fileOverview Random number generator.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ * @author Michael Brooks
+ * @author Steve Thomas
+ */
+
+/** 
+ * @class Random number generator
+ * @description
+ * <b>Use sjcl.random as a singleton for this class!</b>
+ * <p>
+ * This random number generator is a derivative of Ferguson and Schneier's
+ * generator Fortuna.  It collects entropy from various events into several
+ * pools, implemented by streaming SHA-256 instances.  It differs from
+ * ordinary Fortuna in a few ways, though.
+ * </p>
+ *
+ * <p>
+ * Most importantly, it has an entropy estimator.  This is present because
+ * there is a strong conflict here between making the generator available
+ * as soon as possible, and making sure that it doesn't "run on empty".
+ * In Fortuna, there is a saved state file, and the system is likely to have
+ * time to warm up.
+ * </p>
+ *
+ * <p>
+ * Second, because users are unlikely to stay on the page for very long,
+ * and to speed startup time, the number of pools increases logarithmically:
+ * a new pool is created when the previous one is actually used for a reseed.
+ * This gives the same asymptotic guarantees as Fortuna, but gives more
+ * entropy to early reseeds.
+ * </p>
+ *
+ * <p>
+ * The entire mechanism here feels pretty klunky.  Furthermore, there are
+ * several improvements that should be made, including support for
+ * dedicated cryptographic functions that may be present in some browsers;
+ * state files in local storage; cookies containing randomness; etc.  So
+ * look for improvements in future versions.
+ * </p>
+ * @constructor
+ */
+sjcl.prng = function(defaultParanoia) {
+  
+  /* private */
+  this._pools                   = [new sjcl.hash.sha256()];
+  this._poolEntropy             = [0];
+  this._reseedCount             = 0;
+  this._robins                  = {};
+  this._eventId                 = 0;
+  
+  this._collectorIds            = {};
+  this._collectorIdNext         = 0;
+  
+  this._strength                = 0;
+  this._poolStrength            = 0;
+  this._nextReseed              = 0;
+  this._key                     = [0,0,0,0,0,0,0,0];
+  this._counter                 = [0,0,0,0];
+  this._cipher                  = undefined;
+  this._defaultParanoia         = defaultParanoia;
+  
+  /* event listener stuff */
+  this._collectorsStarted       = false;
+  this._callbacks               = {progress: {}, seeded: {}};
+  this._callbackI               = 0;
+  
+  /* constants */
+  this._NOT_READY               = 0;
+  this._READY                   = 1;
+  this._REQUIRES_RESEED         = 2;
+
+  this._MAX_WORDS_PER_BURST     = 65536;
+  this._PARANOIA_LEVELS         = [0,48,64,96,128,192,256,384,512,768,1024];
+  this._MILLISECONDS_PER_RESEED = 30000;
+  this._BITS_PER_RESEED         = 80;
+};
+ 
+sjcl.prng.prototype = {
+  /** Generate several random words, and return them in an array.
+   * A word consists of 32 bits (4 bytes)
+   * @param {Number} nwords The number of words to generate.
+   */
+  randomWords: function (nwords, paranoia) {
+    var out = [], i, readiness = this.isReady(paranoia), g;
+  
+    if (readiness === this._NOT_READY) {
+      throw new sjcl.exception.notReady("generator isn't seeded");
+    } else if (readiness & this._REQUIRES_RESEED) {
+      this._reseedFromPools(!(readiness & this._READY));
+    }
+  
+    for (i=0; i<nwords; i+= 4) {
+      if ((i+1) % this._MAX_WORDS_PER_BURST === 0) {
+        this._gate();
+      }
+   
+      g = this._gen4words();
+      out.push(g[0],g[1],g[2],g[3]);
+    }
+    this._gate();
+  
+    return out.slice(0,nwords);
+  },
+  
+  setDefaultParanoia: function (paranoia, allowZeroParanoia) {
+    if (paranoia === 0 && allowZeroParanoia !== "Setting paranoia=0 will ruin your security; use it only for testing") {
+      throw new sjcl.exception.invalid("Setting paranoia=0 will ruin your security; use it only for testing");
+    }
+
+    this._defaultParanoia = paranoia;
+  },
+  
+  /**
+   * Add entropy to the pools.
+   * @param data The entropic value.  Should be a 32-bit integer, array of 32-bit integers, or string
+   * @param {Number} estimatedEntropy The estimated entropy of data, in bits
+   * @param {String} source The source of the entropy, eg "mouse"
+   */
+  addEntropy: function (data, estimatedEntropy, source) {
+    source = source || "user";
+  
+    var id,
+      i, tmp,
+      t = (new Date()).valueOf(),
+      robin = this._robins[source],
+      oldReady = this.isReady(), err = 0, objName;
+      
+    id = this._collectorIds[source];
+    if (id === undefined) { id = this._collectorIds[source] = this._collectorIdNext ++; }
+      
+    if (robin === undefined) { robin = this._robins[source] = 0; }
+    this._robins[source] = ( this._robins[source] + 1 ) % this._pools.length;
+  
+    switch(typeof(data)) {
+      
+    case "number":
+      if (estimatedEntropy === undefined) {
+        estimatedEntropy = 1;
+      }
+      this._pools[robin].update([id,this._eventId++,1,estimatedEntropy,t,1,data|0]);
+      break;
+      
+    case "object":
+      objName = Object.prototype.toString.call(data);
+      if (objName === "[object Uint32Array]") {
+        tmp = [];
+        for (i = 0; i < data.length; i++) {
+          tmp.push(data[i]);
+        }
+        data = tmp;
+      } else {
+        if (objName !== "[object Array]") {
+          err = 1;
+        }
+        for (i=0; i<data.length && !err; i++) {
+          if (typeof(data[i]) !== "number") {
+            err = 1;
+          }
+        }
+      }
+      if (!err) {
+        if (estimatedEntropy === undefined) {
+          /* horrible entropy estimator */
+          estimatedEntropy = 0;
+          for (i=0; i<data.length; i++) {
+            tmp= data[i];
+            while (tmp>0) {
+              estimatedEntropy++;
+              tmp = tmp >>> 1;
+            }
+          }
+        }
+        this._pools[robin].update([id,this._eventId++,2,estimatedEntropy,t,data.length].concat(data));
+      }
+      break;
+      
+    case "string":
+      if (estimatedEntropy === undefined) {
+       /* English text has just over 1 bit per character of entropy.
+        * But this might be HTML or something, and have far less
+        * entropy than English...  Oh well, let's just say one bit.
+        */
+       estimatedEntropy = data.length;
+      }
+      this._pools[robin].update([id,this._eventId++,3,estimatedEntropy,t,data.length]);
+      this._pools[robin].update(data);
+      break;
+      
+    default:
+      err=1;
+    }
+    if (err) {
+      throw new sjcl.exception.bug("random: addEntropy only supports number, array of numbers or string");
+    }
+  
+    /* record the new strength */
+    this._poolEntropy[robin] += estimatedEntropy;
+    this._poolStrength += estimatedEntropy;
+  
+    /* fire off events */
+    if (oldReady === this._NOT_READY) {
+      if (this.isReady() !== this._NOT_READY) {
+        this._fireEvent("seeded", Math.max(this._strength, this._poolStrength));
+      }
+      this._fireEvent("progress", this.getProgress());
+    }
+  },
+  
+  /** Is the generator ready? */
+  isReady: function (paranoia) {
+    var entropyRequired = this._PARANOIA_LEVELS[ (paranoia !== undefined) ? paranoia : this._defaultParanoia ];
+  
+    if (this._strength && this._strength >= entropyRequired) {
+      return (this._poolEntropy[0] > this._BITS_PER_RESEED && (new Date()).valueOf() > this._nextReseed) ?
+        this._REQUIRES_RESEED | this._READY :
+        this._READY;
+    } else {
+      return (this._poolStrength >= entropyRequired) ?
+        this._REQUIRES_RESEED | this._NOT_READY :
+        this._NOT_READY;
+    }
+  },
+  
+  /** Get the generator's progress toward readiness, as a fraction */
+  getProgress: function (paranoia) {
+    var entropyRequired = this._PARANOIA_LEVELS[ paranoia ? paranoia : this._defaultParanoia ];
+  
+    if (this._strength >= entropyRequired) {
+      return 1.0;
+    } else {
+      return (this._poolStrength > entropyRequired) ?
+        1.0 :
+        this._poolStrength / entropyRequired;
+    }
+  },
+  
+  /** start the built-in entropy collectors */
+  startCollectors: function () {
+    if (this._collectorsStarted) { return; }
+  
+    this._eventListener = {
+      loadTimeCollector: this._bind(this._loadTimeCollector),
+      mouseCollector: this._bind(this._mouseCollector),
+      keyboardCollector: this._bind(this._keyboardCollector),
+      accelerometerCollector: this._bind(this._accelerometerCollector),
+      touchCollector: this._bind(this._touchCollector)
+    };
+
+    if (window.addEventListener) {
+      window.addEventListener("load", this._eventListener.loadTimeCollector, false);
+      window.addEventListener("mousemove", this._eventListener.mouseCollector, false);
+      window.addEventListener("keypress", this._eventListener.keyboardCollector, false);
+      window.addEventListener("devicemotion", this._eventListener.accelerometerCollector, false);
+      window.addEventListener("touchmove", this._eventListener.touchCollector, false);
+    } else if (document.attachEvent) {
+      document.attachEvent("onload", this._eventListener.loadTimeCollector);
+      document.attachEvent("onmousemove", this._eventListener.mouseCollector);
+      document.attachEvent("keypress", this._eventListener.keyboardCollector);
+    } else {
+      throw new sjcl.exception.bug("can't attach event");
+    }
+  
+    this._collectorsStarted = true;
+  },
+  
+  /** stop the built-in entropy collectors */
+  stopCollectors: function () {
+    if (!this._collectorsStarted) { return; }
+  
+    if (window.removeEventListener) {
+      window.removeEventListener("load", this._eventListener.loadTimeCollector, false);
+      window.removeEventListener("mousemove", this._eventListener.mouseCollector, false);
+      window.removeEventListener("keypress", this._eventListener.keyboardCollector, false);
+      window.removeEventListener("devicemotion", this._eventListener.accelerometerCollector, false);
+      window.removeEventListener("touchmove", this._eventListener.touchCollector, false);
+    } else if (document.detachEvent) {
+      document.detachEvent("onload", this._eventListener.loadTimeCollector);
+      document.detachEvent("onmousemove", this._eventListener.mouseCollector);
+      document.detachEvent("keypress", this._eventListener.keyboardCollector);
+    }
+
+    this._collectorsStarted = false;
+  },
+  
+  /* use a cookie to store entropy.
+  useCookie: function (all_cookies) {
+      throw new sjcl.exception.bug("random: useCookie is unimplemented");
+  },*/
+  
+  /** add an event listener for progress or seeded-ness. */
+  addEventListener: function (name, callback) {
+    this._callbacks[name][this._callbackI++] = callback;
+  },
+  
+  /** remove an event listener for progress or seeded-ness */
+  removeEventListener: function (name, cb) {
+    var i, j, cbs=this._callbacks[name], jsTemp=[];
+
+    /* I'm not sure if this is necessary; in C++, iterating over a
+     * collection and modifying it at the same time is a no-no.
+     */
+
+    for (j in cbs) {
+      if (cbs.hasOwnProperty(j) && cbs[j] === cb) {
+        jsTemp.push(j);
+      }
+    }
+
+    for (i=0; i<jsTemp.length; i++) {
+      j = jsTemp[i];
+      delete cbs[j];
+    }
+  },
+  
+  _bind: function (func) {
+    var that = this;
+    return function () {
+      func.apply(that, arguments);
+    };
+  },
+
+  /** Generate 4 random words, no reseed, no gate.
+   * @private
+   */
+  _gen4words: function () {
+    for (var i=0; i<4; i++) {
+      this._counter[i] = this._counter[i]+1 | 0;
+      if (this._counter[i]) { break; }
+    }
+    return this._cipher.encrypt(this._counter);
+  },
+  
+  /* Rekey the AES instance with itself after a request, or every _MAX_WORDS_PER_BURST words.
+   * @private
+   */
+  _gate: function () {
+    this._key = this._gen4words().concat(this._gen4words());
+    this._cipher = new sjcl.cipher.aes(this._key);
+  },
+  
+  /** Reseed the generator with the given words
+   * @private
+   */
+  _reseed: function (seedWords) {
+    this._key = sjcl.hash.sha256.hash(this._key.concat(seedWords));
+    this._cipher = new sjcl.cipher.aes(this._key);
+    for (var i=0; i<4; i++) {
+      this._counter[i] = this._counter[i]+1 | 0;
+      if (this._counter[i]) { break; }
+    }
+  },
+  
+  /** reseed the data from the entropy pools
+   * @param full If set, use all the entropy pools in the reseed.
+   */
+  _reseedFromPools: function (full) {
+    var reseedData = [], strength = 0, i;
+  
+    this._nextReseed = reseedData[0] =
+      (new Date()).valueOf() + this._MILLISECONDS_PER_RESEED;
+    
+    for (i=0; i<16; i++) {
+      /* On some browsers, this is cryptographically random.  So we might
+       * as well toss it in the pot and stir...
+       */
+      reseedData.push(Math.random()*0x100000000|0);
+    }
+    
+    for (i=0; i<this._pools.length; i++) {
+     reseedData = reseedData.concat(this._pools[i].finalize());
+     strength += this._poolEntropy[i];
+     this._poolEntropy[i] = 0;
+   
+     if (!full && (this._reseedCount & (1<<i))) { break; }
+    }
+  
+    /* if we used the last pool, push a new one onto the stack */
+    if (this._reseedCount >= 1 << this._pools.length) {
+     this._pools.push(new sjcl.hash.sha256());
+     this._poolEntropy.push(0);
+    }
+  
+    /* how strong was this reseed? */
+    this._poolStrength -= strength;
+    if (strength > this._strength) {
+      this._strength = strength;
+    }
+  
+    this._reseedCount ++;
+    this._reseed(reseedData);
+  },
+  
+  _keyboardCollector: function () {
+    this._addCurrentTimeToEntropy(1);
+  },
+  
+  _mouseCollector: function (ev) {
+    var x, y;
+
+    try {
+      x = ev.x || ev.clientX || ev.offsetX || 0;
+      y = ev.y || ev.clientY || ev.offsetY || 0;
+    } catch (err) {
+      // Event originated from a secure element. No mouse position available.
+      x = 0;
+      y = 0;
+    }
+
+    if (x != 0 && y!= 0) {
+      this.addEntropy([x,y], 2, "mouse");
+    }
+
+    this._addCurrentTimeToEntropy(0);
+  },
+
+  _touchCollector: function(ev) {
+    var touch = ev.touches[0] || ev.changedTouches[0];
+    var x = touch.pageX || touch.clientX,
+        y = touch.pageY || touch.clientY;
+
+    this.addEntropy([x,y],1,"touch");
+
+    this._addCurrentTimeToEntropy(0);
+  },
+  
+  _loadTimeCollector: function () {
+    this._addCurrentTimeToEntropy(2);
+  },
+
+  _addCurrentTimeToEntropy: function (estimatedEntropy) {
+    if (typeof window !== 'undefined' && window.performance && typeof window.performance.now === "function") {
+      //how much entropy do we want to add here?
+      this.addEntropy(window.performance.now(), estimatedEntropy, "loadtime");
+    } else {
+      this.addEntropy((new Date()).valueOf(), estimatedEntropy, "loadtime");
+    }
+  },
+  _accelerometerCollector: function (ev) {
+    var ac = ev.accelerationIncludingGravity.x||ev.accelerationIncludingGravity.y||ev.accelerationIncludingGravity.z;
+    if(window.orientation){
+      var or = window.orientation;
+      if (typeof or === "number") {
+        this.addEntropy(or, 1, "accelerometer");
+      }
+    }
+    if (ac) {
+      this.addEntropy(ac, 2, "accelerometer");
+    }
+    this._addCurrentTimeToEntropy(0);
+  },
+
+  _fireEvent: function (name, arg) {
+    var j, cbs=sjcl.random._callbacks[name], cbsTemp=[];
+    /* TODO: there is a race condition between removing collectors and firing them */
+
+    /* I'm not sure if this is necessary; in C++, iterating over a
+     * collection and modifying it at the same time is a no-no.
+     */
+
+    for (j in cbs) {
+      if (cbs.hasOwnProperty(j)) {
+        cbsTemp.push(cbs[j]);
+      }
+    }
+
+    for (j=0; j<cbsTemp.length; j++) {
+      cbsTemp[j](arg);
+    }
+  }
+};
+
+/** an instance for the prng.
+* @see sjcl.prng
+*/
+sjcl.random = new sjcl.prng(6);
+
+(function(){
+  // function for getting nodejs crypto module. catches and ignores errors.
+  function getCryptoModule() {
+    try {
+      return require('crypto');
+    }
+    catch (e) {
+      return null;
+    }
+  }
+
+  try {
+    var buf, crypt, ab;
+
+    // get cryptographically strong entropy depending on runtime environment
+    if (typeof module !== 'undefined' && module.exports && (crypt = getCryptoModule()) && crypt.randomBytes) {
+      buf = crypt.randomBytes(1024/8);
+      buf = new Uint32Array(new Uint8Array(buf).buffer);
+      sjcl.random.addEntropy(buf, 1024, "crypto.randomBytes");
+
+    } else if (typeof window !== 'undefined' && typeof Uint32Array !== 'undefined') {
+      ab = new Uint32Array(32);
+      if (window.crypto && window.crypto.getRandomValues) {
+        window.crypto.getRandomValues(ab);
+      } else if (window.msCrypto && window.msCrypto.getRandomValues) {
+        window.msCrypto.getRandomValues(ab);
+      } else {
+        return;
+      }
+
+      // get cryptographically strong entropy in Webkit
+      sjcl.random.addEntropy(ab, 1024, "crypto.getRandomValues");
+
+    } else {
+      // no getRandomValues :-(
+    }
+  } catch (e) {
+    if (typeof window !== 'undefined' && window.console) {
+      console.log("There was an error collecting entropy from the browser:");
+      console.log(e);
+      //we do not want the library to fail due to randomness not being maintained.
+    }
+  }
+}());
+/** @fileOverview Convenience functions centered around JSON encapsulation.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+ /**
+  * JSON encapsulation
+  * @namespace
+  */
+ sjcl.json = {
+  /** Default values for encryption */
+  defaults: { v:1, iter:10000, ks:128, ts:64, mode:"ccm", adata:"", cipher:"aes" },
+
+  /** Simple encryption function.
+   * @param {String|bitArray} password The password or key.
+   * @param {String} plaintext The data to encrypt.
+   * @param {Object} [params] The parameters including tag, iv and salt.
+   * @param {Object} [rp] A returned version with filled-in parameters.
+   * @return {Object} The cipher raw data.
+   * @throws {sjcl.exception.invalid} if a parameter is invalid.
+   */
+  _encrypt: function (password, plaintext, params, rp) {
+    params = params || {};
+    rp = rp || {};
+
+    var j = sjcl.json, p = j._add({ iv: sjcl.random.randomWords(4,0) },
+                                  j.defaults), tmp, prp, adata;
+    j._add(p, params);
+    adata = p.adata;
+    if (typeof p.salt === "string") {
+      p.salt = sjcl.codec.base64.toBits(p.salt);
+    }
+    if (typeof p.iv === "string") {
+      p.iv = sjcl.codec.base64.toBits(p.iv);
+    }
+
+    if (!sjcl.mode[p.mode] ||
+        !sjcl.cipher[p.cipher] ||
+        (typeof password === "string" && p.iter <= 100) ||
+        (p.ts !== 64 && p.ts !== 96 && p.ts !== 128) ||
+        (p.ks !== 128 && p.ks !== 192 && p.ks !== 256) ||
+        (p.iv.length < 2 || p.iv.length > 4)) {
+      throw new sjcl.exception.invalid("json encrypt: invalid parameters");
+    }
+
+    if (typeof password === "string") {
+      tmp = sjcl.misc.cachedPbkdf2(password, p);
+      password = tmp.key.slice(0,p.ks/32);
+      p.salt = tmp.salt;
+    } else if (sjcl.ecc && password instanceof sjcl.ecc.elGamal.publicKey) {
+      tmp = password.kem();
+      p.kemtag = tmp.tag;
+      password = tmp.key.slice(0,p.ks/32);
+    }
+    if (typeof plaintext === "string") {
+      plaintext = sjcl.codec.utf8String.toBits(plaintext);
+    }
+    if (typeof adata === "string") {
+      p.adata = adata = sjcl.codec.utf8String.toBits(adata);
+    }
+    prp = new sjcl.cipher[p.cipher](password);
+
+    /* return the json data */
+    j._add(rp, p);
+    rp.key = password;
+
+    /* do the encryption */
+    if (p.mode === "ccm" && sjcl.arrayBuffer && sjcl.arrayBuffer.ccm && plaintext instanceof ArrayBuffer) {
+      p.ct = sjcl.arrayBuffer.ccm.encrypt(prp, plaintext, p.iv, adata, p.ts);
+    } else {
+      p.ct = sjcl.mode[p.mode].encrypt(prp, plaintext, p.iv, adata, p.ts);
+    }
+
+    //return j.encode(j._subtract(p, j.defaults));
+    return p;
+  },
+
+  /** Simple encryption function.
+   * @param {String|bitArray} password The password or key.
+   * @param {String} plaintext The data to encrypt.
+   * @param {Object} [params] The parameters including tag, iv and salt.
+   * @param {Object} [rp] A returned version with filled-in parameters.
+   * @return {String} The ciphertext serialized data.
+   * @throws {sjcl.exception.invalid} if a parameter is invalid.
+   */
+  encrypt: function (password, plaintext, params, rp) {
+    var j = sjcl.json, p = j._encrypt.apply(j, arguments);
+    return j.encode(p);
+  },
+
+  /** Simple decryption function.
+   * @param {String|bitArray} password The password or key.
+   * @param {Object} ciphertext The cipher raw data to decrypt.
+   * @param {Object} [params] Additional non-default parameters.
+   * @param {Object} [rp] A returned object with filled parameters.
+   * @return {String} The plaintext.
+   * @throws {sjcl.exception.invalid} if a parameter is invalid.
+   * @throws {sjcl.exception.corrupt} if the ciphertext is corrupt.
+   */
+  _decrypt: function (password, ciphertext, params, rp) {
+    params = params || {};
+    rp = rp || {};
+
+    var j = sjcl.json, p = j._add(j._add(j._add({},j.defaults),ciphertext), params, true), ct, tmp, prp, adata=p.adata;
+    if (typeof p.salt === "string") {
+      p.salt = sjcl.codec.base64.toBits(p.salt);
+    }
+    if (typeof p.iv === "string") {
+      p.iv = sjcl.codec.base64.toBits(p.iv);
+    }
+
+    if (!sjcl.mode[p.mode] ||
+        !sjcl.cipher[p.cipher] ||
+        (typeof password === "string" && p.iter <= 100) ||
+        (p.ts !== 64 && p.ts !== 96 && p.ts !== 128) ||
+        (p.ks !== 128 && p.ks !== 192 && p.ks !== 256) ||
+        (!p.iv) ||
+        (p.iv.length < 2 || p.iv.length > 4)) {
+      throw new sjcl.exception.invalid("json decrypt: invalid parameters");
+    }
+
+    if (typeof password === "string") {
+      tmp = sjcl.misc.cachedPbkdf2(password, p);
+      password = tmp.key.slice(0,p.ks/32);
+      p.salt  = tmp.salt;
+    } else if (sjcl.ecc && password instanceof sjcl.ecc.elGamal.secretKey) {
+      password = password.unkem(sjcl.codec.base64.toBits(p.kemtag)).slice(0,p.ks/32);
+    }
+    if (typeof adata === "string") {
+      adata = sjcl.codec.utf8String.toBits(adata);
+    }
+    prp = new sjcl.cipher[p.cipher](password);
+
+    /* do the decryption */
+    if (p.mode === "ccm" && sjcl.arrayBuffer && sjcl.arrayBuffer.ccm && p.ct instanceof ArrayBuffer) {
+      ct = sjcl.arrayBuffer.ccm.decrypt(prp, p.ct, p.iv, p.tag, adata, p.ts);
+    } else {
+      ct = sjcl.mode[p.mode].decrypt(prp, p.ct, p.iv, adata, p.ts);
+    }
+
+    /* return the json data */
+    j._add(rp, p);
+    rp.key = password;
+
+    if (params.raw === 1) {
+      return ct;
+    } else {
+      return sjcl.codec.utf8String.fromBits(ct);
+    }
+  },
+
+  /** Simple decryption function.
+   * @param {String|bitArray} password The password or key.
+   * @param {String} ciphertext The ciphertext to decrypt.
+   * @param {Object} [params] Additional non-default parameters.
+   * @param {Object} [rp] A returned object with filled parameters.
+   * @return {String} The plaintext.
+   * @throws {sjcl.exception.invalid} if a parameter is invalid.
+   * @throws {sjcl.exception.corrupt} if the ciphertext is corrupt.
+   */
+  decrypt: function (password, ciphertext, params, rp) {
+    var j = sjcl.json;
+    return j._decrypt(password, j.decode(ciphertext), params, rp);
+  },
+
+  /** Encode a flat structure into a JSON string.
+   * @param {Object} obj The structure to encode.
+   * @return {String} A JSON string.
+   * @throws {sjcl.exception.invalid} if obj has a non-alphanumeric property.
+   * @throws {sjcl.exception.bug} if a parameter has an unsupported type.
+   */
+  encode: function (obj) {
+    var i, out='{', comma='';
+    for (i in obj) {
+      if (obj.hasOwnProperty(i)) {
+        if (!i.match(/^[a-z0-9]+$/i)) {
+          throw new sjcl.exception.invalid("json encode: invalid property name");
+        }
+        out += comma + '"' + i + '":';
+        comma = ',';
+
+        switch (typeof obj[i]) {
+          case 'number':
+          case 'boolean':
+            out += obj[i];
+            break;
+
+          case 'string':
+            out += '"' + escape(obj[i]) + '"';
+            break;
+
+          case 'object':
+            out += '"' + sjcl.codec.base64.fromBits(obj[i],0) + '"';
+            break;
+
+          default:
+            throw new sjcl.exception.bug("json encode: unsupported type");
+        }
+      }
+    }
+    return out+'}';
+  },
+
+  /** Decode a simple (flat) JSON string into a structure.  The ciphertext,
+   * adata, salt and iv will be base64-decoded.
+   * @param {String} str The string.
+   * @return {Object} The decoded structure.
+   * @throws {sjcl.exception.invalid} if str isn't (simple) JSON.
+   */
+  decode: function (str) {
+    str = str.replace(/\s/g,'');
+    if (!str.match(/^\{.*\}$/)) {
+      throw new sjcl.exception.invalid("json decode: this isn't json!");
+    }
+    var a = str.replace(/^\{|\}$/g, '').split(/,/), out={}, i, m;
+    for (i=0; i<a.length; i++) {
+      if (!(m=a[i].match(/^\s*(?:(["']?)([a-z][a-z0-9]*)\1)\s*:\s*(?:(-?\d+)|"([a-z0-9+\/%*_.@=\-]*)"|(true|false))$/i))) {
+        throw new sjcl.exception.invalid("json decode: this isn't json!");
+      }
+      if (m[3] != null) {
+        out[m[2]] = parseInt(m[3],10);
+      } else if (m[4] != null) {
+        out[m[2]] = m[2].match(/^(ct|adata|salt|iv)$/) ? sjcl.codec.base64.toBits(m[4]) : unescape(m[4]);
+      } else if (m[5] != null) {
+        out[m[2]] = m[5] === 'true';
+      }
+    }
+    return out;
+  },
+
+  /** Insert all elements of src into target, modifying and returning target.
+   * @param {Object} target The object to be modified.
+   * @param {Object} src The object to pull data from.
+   * @param {boolean} [requireSame=false] If true, throw an exception if any field of target differs from corresponding field of src.
+   * @return {Object} target.
+   * @private
+   */
+  _add: function (target, src, requireSame) {
+    if (target === undefined) { target = {}; }
+    if (src === undefined) { return target; }
+    var i;
+    for (i in src) {
+      if (src.hasOwnProperty(i)) {
+        if (requireSame && target[i] !== undefined && target[i] !== src[i]) {
+          throw new sjcl.exception.invalid("required parameter overridden");
+        }
+        target[i] = src[i];
+      }
+    }
+    return target;
+  },
+
+  /** Remove all elements of minus from plus.  Does not modify plus.
+   * @private
+   */
+  _subtract: function (plus, minus) {
+    var out = {}, i;
+
+    for (i in plus) {
+      if (plus.hasOwnProperty(i) && plus[i] !== minus[i]) {
+        out[i] = plus[i];
+      }
+    }
+
+    return out;
+  },
+
+  /** Return only the specified elements of src.
+   * @private
+   */
+  _filter: function (src, filter) {
+    var out = {}, i;
+    for (i=0; i<filter.length; i++) {
+      if (src[filter[i]] !== undefined) {
+        out[filter[i]] = src[filter[i]];
+      }
+    }
+    return out;
+  }
+};
+
+/** Simple encryption function; convenient shorthand for sjcl.json.encrypt.
+ * @param {String|bitArray} password The password or key.
+ * @param {String} plaintext The data to encrypt.
+ * @param {Object} [params] The parameters including tag, iv and salt.
+ * @param {Object} [rp] A returned version with filled-in parameters.
+ * @return {String} The ciphertext.
+ */
+sjcl.encrypt = sjcl.json.encrypt;
+
+/** Simple decryption function; convenient shorthand for sjcl.json.decrypt.
+ * @param {String|bitArray} password The password or key.
+ * @param {String} ciphertext The ciphertext to decrypt.
+ * @param {Object} [params] Additional non-default parameters.
+ * @param {Object} [rp] A returned object with filled parameters.
+ * @return {String} The plaintext.
+ */
+sjcl.decrypt = sjcl.json.decrypt;
+
+/** The cache for cachedPbkdf2.
+ * @private
+ */
+sjcl.misc._pbkdf2Cache = {};
+
+/** Cached PBKDF2 key derivation.
+ * @param {String} password The password.
+ * @param {Object} [obj] The derivation params (iteration count and optional salt).
+ * @return {Object} The derived data in key, the salt in salt.
+ */
+sjcl.misc.cachedPbkdf2 = function (password, obj) {
+  var cache = sjcl.misc._pbkdf2Cache, c, cp, str, salt, iter;
+
+  obj = obj || {};
+  iter = obj.iter || 1000;
+
+  /* open the cache for this password and iteration count */
+  cp = cache[password] = cache[password] || {};
+  c = cp[iter] = cp[iter] || { firstSalt: (obj.salt && obj.salt.length) ?
+                     obj.salt.slice(0) : sjcl.random.randomWords(2,0) };
+
+  salt = (obj.salt === undefined) ? c.firstSalt : obj.salt;
+
+  c[salt] = c[salt] || sjcl.misc.pbkdf2(password, salt, obj.iter);
+  return { key: c[salt].slice(0), salt:salt.slice(0) };
+};
+if(typeof module !== 'undefined' && module.exports){
+  module.exports = sjcl;
+}
+if (typeof define === "function") {
+    define([], function () {
+        return sjcl;
+    });
+}
diff --git a/static/js/node_store.mjs b/static/js/node_store.mjs
index bf7c4e8..6be8f82 100644
--- a/static/js/node_store.mjs
+++ b/static/js/node_store.mjs
@@ -1,218 +1,12 @@
+import { Node } from 'node'
+
 export const ROOT_NODE = '00000000-0000-0000-0000-000000000000'
 export const ORPHANED_NODE = '00000000-0000-0000-0000-000000000001'
 export const DELETED_NODE = '00000000-0000-0000-0000-000000000002'
 
-export class Node {
-	static sort(a, b) {//{{{
-		// Nodes with children ("folders") are sorted first.
-		if (a._has_children && !b._has_children) return -1
-		if (!a._has_children && b._has_children) return 1
-
-		// Otherwise sort by lowercased name.
-		const an = a.data.Name.toLowerCase()
-		const bn = b.data.Name.toLowerCase()
-		if (an < bn) return -1
-		if (an > bn) return 1
-		return 0
-	}//}}}
-	static create(name, parentUUID) {// {{{
-		const node = new Node({
-			UUID: uuidv7(),
-			Created: (new Date()).toISOString(),
-			Content: '',
-			Name: name,
-			ParentUUID: parentUUID,
-			Markdown: false,
-		})
-
-		// Newly created node (not constructed from existing data) is considered modified
-		// since node.save returns early if it isn't modified.
-		node._modified = true
-
-		return node
-	}// }}}
-
-	constructor(nodeData, level) {//{{{
-		this.Level = level
-		this.data = nodeData
-		this.UUID = nodeData.UUID
-
-		// Toplevel nodes are normalized to have the ROOT_NODE as parent.
-		if (nodeData.UUID !== ROOT_NODE && nodeData.ParentUUID === '') {
-			this.ParentUUID = ROOT_NODE
-			this.data.ParentUUID = ROOT_NODE
-		} else
-			this.ParentUUID = nodeData.ParentUUID
-
-		this._children_fetched = false
-		this._has_children = null // this will be set by nodeStore.getTreeNodes
-		this.Children = []
-		this.Ancestors = []
-
-		this._sibling_before = null
-		this._sibling_after = null
-		this._parent = null
-
-		this.reset()
-	}//}}}
-
-	reset() {// {{{
-		// this._content is the runtime content in the editor.
-		// this.data.Content is the original data.
-		this._content = this.data.Content
-		this._modified = false
-	}// }}}
-	get(prop) {//{{{
-		return this.data[prop]
-	}//}}}
-	updated() {//{{{
-		// '2024-12-17T17:33:48.85939Z
-		return new Date(Date.parse(this.data.Updated))
-	}//}}}
-	isModified() {// {{{
-		return this._modified
-	}// }}}
-	hasFetchedChildren() {//{{{
-		return this._children_fetched
-	}//}}}
-	async fetchChildren() {//{{{
-		this.Children = await globalThis.nodeStore.getTreeNodes(this.UUID, this.Level + 1)
-		this._children_fetched = true
-
-		// Children are sorted to allow for storing siblings befare and after.
-		// These are used with keyboard navigation in the tree.
-		this.Children.sort(Node.sort)
-
-		const numChildren = this.Children.length
-		this.setHasChildren(numChildren > 0)
-		for (let i = 0; i < numChildren; i++) {
-			if (i > 0)
-				this.Children[i]._sibling_before = this.Children[i - 1]
-			if (i < numChildren - 1)
-				this.Children[i]._sibling_after = this.Children[i + 1]
-			this.Children[i]._parent = this
-		}
-
-		return this.Children
-	}//}}}
-	setHasChildren(v) {// {{{
-		this._has_children = v
-	}// }}}
-	hasChildren() {//{{{
-		return this._has_children
-	}//}}}
-	getSiblingBefore() {// {{{
-		return this._sibling_before
-	}// }}}
-	getSiblingAfter() {// {{{
-		return this._sibling_after
-	}// }}}
-	getParent() {//{{{
-		return this._parent
-	}//}}}
-	moveToParent(newParentUUID) {// {{{
-		if (this.UUID === newParentUUID)
-			throw new Error("New parent UUID is the same as node UUID. Can't be your own parent.")
-
-		this.ParentUUID = newParentUUID
-		this.data.ParentUUID = newParentUUID
-		this._modified = true
-	}// }}}
-	isLastSibling() {//{{{
-		return this._sibling_after === null
-	}//}}}
-	isFirstSibling() {//{{{
-		return this._sibling_before === null
-	}//}}}
-	isSpecial() {// {{{
-		return this.data.Special
-	}// }}}
-	content() {//{{{
-		// TODO - implement crypto
-		return this._content
-	}//}}}
-	setContent(new_content) {//{{{
-		this._content = new_content
-		this._modified = true
-		_mbus.dispatch('NODE_MODIFIED', { node: this })
-	}//}}}
-	setName(new_name) {// {{{
-		if (new_name.trim() === '')
-			throw new Error(`The name can't be empty`)
-
-		this.data.Name = new_name
-		this._modified = true
-		_mbus.dispatch('NODE_MODIFIED', { node: this })
-	}// }}}
-	async save() {//{{{
-		try {
-			const dblink = /db:\/\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/gi
-
-			// Just safeguarding not using the root node,
-			// which sort of exist but isn't supposed to communicate to server.
-			if (this.UUID == ROOT_NODE)
-				return
-
-			// File links from the original, unmodified content are found to compare to links from the new content.
-			// All files (images) needs to be indexed to nodes in order to track orphaned files.
-			const before = new Set([...this.data.Content.matchAll(dblink)].map(m => m[1]))
-			const after = new Set([...this._content.matchAll(dblink)].map(m => m[1]))
-			const removed = before.difference(after)
-			const added = after.difference(before)
-
-			await globalThis.nodeStore.filesNodelink.removeFileUUIDs(this.UUID, removed)
-			await globalThis.nodeStore.filesNodelink.addFileUUIDs(this.UUID, added)
-
-			// Authoritative content and metadata is set to prepare it for IndexedDB update.
-			this.data.Content = this._content
-			this.data.Updated = new Date().toISOString()
-			this.data.HistoryUUID = uuidv7() // every time the node is saved a new history UUID identifies the changed node.
-
-			_mbus.dispatch('NODE_UNMODIFIED')
-			this._modified = false
-
-			// When stored into database and ancestry was changed,
-			// the ancestry path could be interesting.
-			/*
-			const ancestors = await nodeStore.getNodeAncestry(this)
-			this.data.Ancestors = ancestors.map(a => a.get('Name')).reverse()
-			*/
-
-			/* The node history is a local store for node history.
-			 * This could be provisioned from the server or cleared if
-			 * deemed unnecessary.
-			 *
-			 * The send queue is what will be sent back to the server
-			 * to have a recorded history of the notes.
-			 *
-			 * A setting to be implemented in the future could be to
-			 * not save the history locally at all. */
-
-			// Current node is added to history. It will be duplicated with the "nodes" store
-			// for simplicity, to hopefully avoid bugs.
-			const history = globalThis.nodeStore.nodesHistory.add(this)
-
-			// Updated node is added to the send queue to be stored on server.
-
-			const sendQueue = globalThis.nodeStore.sendQueue.add(this)
-
-			// Updated node is saved to the primary node store.
-			const nodeStoreAdding = globalThis.nodeStore.add([this])
-
-			await Promise.all([history, sendQueue, nodeStoreAdding])
-
-		} catch (err) {
-			console.error(err)
-			alert(err.message)
-		}
-
-		return
-	}//}}}
-}
-
 export class NodeStore {
 	constructor() {//{{{
-		if (!('indexedDB' in self)) {
+		if (!('indexedDB' in window)) {
 			throw 'Missing IndexedDB'
 		}
 
@@ -221,13 +15,12 @@ export class NodeStore {
 		this.sendQueue = null
 		this.nodesHistory = null
 		this.files = null
-		this.filesMetadata = null
 
 		this.initializeSpecialNodes()
 	}//}}}
 	initializeDB() {//{{{
 		return new Promise((resolve, reject) => {
-			const req = indexedDB.open('notes', 14)
+			const req = indexedDB.open('notes', 8)
 
 			// Schema upgrades for IndexedDB.
 			// These can start from different points depending on updates to Notes2 since a device was online.
@@ -278,30 +71,6 @@ export class NodeStore {
 						case 8:
 							files = db.createObjectStore('files', { keyPath: 'UUID' })
 							break
-
-						case 9:
-							db.createObjectStore('files_metadata', { keyPath: 'UUID' })
-							break
-
-						case 10:
-							trx.objectStore('files_metadata').createIndex('byUploaded', 'uploaded', { unique: false })
-							break
-
-						case 11:
-							db.createObjectStore('files_nodelink', { keyPath: 'UUID' })
-							break
-
-						case 12:
-							trx.objectStore('files_nodelink').createIndex('byNodeCount', 'NodeCount', { unique: false })
-							break
-
-						case 13:
-							db.createObjectStore('file_segments', { keyPath: ['UUID', 'Sequence'] })
-							break
-
-						case 14:
-							db.deleteObjectStore('files')
-							break
 					}
 				}
 			}
@@ -311,9 +80,6 @@ export class NodeStore {
 				this.sendQueue = new SimpleNodeStore(this.db, 'send_queue')
 				this.nodesHistory = new NodeHistoryStore(this.db, 'nodes_history')
 				this.files = new SimpleNodeStore(this.db, 'files')
-				this.fileSegments = new FileSegmentsStore(this.db, 'file_segments')
-				this.filesMetadata = new FilesMetadataStore(this.db, 'files_metadata')
-				this.filesNodelink = new FileNodesLinkStore(this.db, 'files_nodelink')
 				resolve()
 			}
 
@@ -455,6 +221,7 @@ export class NodeStore {
 					nodeStore = t.objectStore('nodes')
 
 					t.oncomplete = (_event) => {
+						console.log('complete')
 						resolve()
 					}
 
@@ -565,66 +332,6 @@ export class NodeStore {
 			}
 		})
 	}//}}}
-
-	async storeFile(file) {// {{{
-		const metadata = new FileMetadata(file)
-
-		try {
-			// Do potentially larger blocks.
-			const BLOCKSIZE = 1048576
-			const stream = file.stream()
-			const reader = stream.getReader({ mode: 'byob' })
-			let buffer = new Uint8Array(BLOCKSIZE)
-
-			let seq = 0
-			while (true) {
-				const { done, value } = await reader.read(buffer)
-				if (done) break
-
-				// Block is added as a file segment.
-				await this.fileSegments.add({
-					data: {
-						UUID: metadata.UUID,
-						Sequence: seq,
-						Data: value,
-					}
-				})
-				buffer = new Uint8Array(value.buffer)
-				seq++
-			}
-
-			reader.releaseLock()
-		} catch (e) {
-			console.error(e)
-			alert(e.message)
-		}
-
-		await this.filesMetadata.add({ data: metadata })
-
-		return metadata
-	}// }}}
-	nextFileToSync() {// {{{
-		return new Promise((resolve, reject) => {
-			const req = this.db
-				.transaction('files_metadata', 'readonly')
-				.objectStore('files_metadata')
-				.index('byUploaded')
-				.get('only_on_device')
-
-			req.onerror = (e) => reject(e)
-			req.onsuccess = (e) => {
-				const data = e.target.result
-
-				// No more files to sync.
-				if (data === undefined) {
-					resolve(null)
-					return
-				}
-
-				resolve(new FileMetadata(data))
-			}
-		})
-	}// }}}
 }
 
 class SimpleNodeStore {
@@ -644,6 +351,7 @@ class SimpleNodeStore {
 			// Node to be moved is first stored in the new queue.
 			const req = store.put(node.data)
 			req.onsuccess = () => {
+				console.log('here')
 				resolve()
 			}
 			req.onerror = (event) => {
@@ -752,7 +460,7 @@ class NodeHistoryStore extends SimpleNodeStore {
 			}
 
 			req.onerror = (event) => {
-				console.error(event.target.error)
+				console.log(event.target.error)
 				reject(event.target.error)
 			}
 		})
@@ -805,120 +513,6 @@ class NodeHistoryStore extends SimpleNodeStore {
 	}// }}}
 }
 
-class FileSegmentsStore extends SimpleNodeStore {
-	constructor(db, storeName) {//{{{
-		super(db, storeName)
-	}//}}}
-	async getStream(uuid) {// {{{
-		let seq = 0
-		const meself = this
-
-		return new ReadableStream({
-			type: 'bytes',
-
-			async pull(controller) {
-				try {
-					while (true) {
-						const chunk = await meself.get([uuid, seq])
-						if (!chunk) {
-							controller.close()
-							return
-						}
-
-						controller.enqueue(chunk.Data)
-						seq++
-					}
-				} catch (e) {
-					console.error(e)
-				}
-			}
-		})
-	}// }}}
-}
-
-class FilesMetadataStore extends SimpleNodeStore {
-	countToUpload() {// {{{
-		const store = this.db
-			.transaction(this.storeName, 'readonly')
-			.objectStore(this.storeName)
-			.index('byUploaded')
-		return new Promise((resolve, reject) => {
-			const request = store.count('only_on_device')
-			request.onsuccess = (event) => resolve(event.target.result)
-			request.onerror = (event) => reject(event.target.error)
-		})
-	}// }}}
-}
-
-class FileNodesLinkStore extends SimpleNodeStore {
-	async removeFileUUIDs(nodeUUID, fileUUIDs) {// {{{
-		for (const fileUUID of fileUUIDs) {
-			let nodelink = await this.get(fileUUID)
-
-			// Nothing to remove from.
-			if (nodelink === undefined)
-				continue
-
-			const idx = nodelink.Nodes.indexOf(nodeUUID)
-			if (idx > -1)
-				nodelink.Nodes.splice(idx, 1)
-
-			// Maintains an index to quickly find orphaned files.
-			nodelink.NodeCount = nodelink.Nodes.length
-
-			await this.add({ data: nodelink })
-		}
-	}// }}}
-	async addFileUUIDs(nodeUUID, fileUUIDs) {// {{{
-		for (const fileUUID of fileUUIDs) {
-			let nodelink = await this.get(fileUUID)
-
-			// Needs to be initialized if not existing already.
-			if (nodelink === undefined)
-				nodelink = {
-					UUID: fileUUID,
-					Nodes: [nodeUUID],
-				}
-
-			// Can get called with the same UUID as already there.
-			// No duplicates, only append if missing.
-			if (!nodelink.Nodes.includes(nodeUUID))
-				nodelink.Nodes.push(nodeUUID)
-
-			// Maintains an index to quickly find orphaned files.
-			nodelink.NodeCount = nodelink.Nodes.length
-
-			await this.add({ data: nodelink })
-		}
-	}// }}}
-}
-
-class FileMetadata {
-	constructor(data) {// {{{
-		console.log('md', data)
-		this.UUID = data.UUID || uuidv7()
-		this.uploaded = data.uploaded || 'only_on_device'
-
-		this.name = data.name
-		this.size = data.size
-		this.type = data.type || 'application/octet-stream'
-		this.modified = data.modified || data.lastModified || Date.now()
-	}// }}}
-	setUploaded() {// {{{
-		this.uploaded = 'on_server'
-	}// }}}
-	get data() {// {{{
-		return {
-			UUID: this.UUID,
-			uploaded: this.uploaded,
-			name: this.name,
-			size: this.size,
-			type: this.type,
-			modified: this.modified,
-		}
-	}// }}}
-}
-
 export function uuidv7() {// {{{
 	// random bytes
 	const value = new Uint8Array(16)
diff --git a/static/js/page_history.mjs b/static/js/page_history.mjs
index 2c03193..44061f6 100644
--- a/static/js/page_history.mjs
+++ b/static/js/page_history.mjs
@@ -1,5 +1,5 @@
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
-import { Node } from 'node_store'
+import { Node } from './page_node.mjs'
 import { MarkedPosition } from './marked_position.mjs'
 
 
diff --git a/static/js/page_node.mjs b/static/js/page_node.mjs
index 574fe96..2106ada 100644
--- a/static/js/page_node.mjs
+++ b/static/js/page_node.mjs
@@ -1,3 +1,4 @@
+import { ROOT_NODE, uuidv7 } from 'node_store'
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
 import { MarkedPosition } from './marked_position.mjs'
 
@@ -266,11 +267,11 @@ export class N2PageNodeUI extends CustomHTMLElement {
 					const file = item.getAsFile()
 					if (!file)
 						throw new Error("Couldn't convert image to file object.")
-
-					const fileMetadata = await globalThis.nodeStore.storeFile(file)
+					const uuid = uuidv7()
+					await globalThis.nodeStore.files.add({ data: { UUID: uuid, file: file } })
 
 					const [start, end] = [this.elNodeContent.selectionStart, this.elNodeContent.selectionEnd]
-					this.elNodeContent.setRangeText(`![${file.name}](db://${fileMetadata.UUID})`, start, end, 'select');
+					this.elNodeContent.setRangeText(`![${file.name}](db://${uuid})`, start, end, 'select');
 
 					// Editing the textarea programatically doesn't generate the events it usually gets when edited interactively.
 					this.node.setContent(this.elNodeContent.value)
@@ -397,4 +398,196 @@ export class N2PageNodeUI extends CustomHTMLElement {
 }
 customElements.define('n2-nodeui', N2PageNodeUI)
 
+export class Node {
+	static sort(a, b) {//{{{
+		// Nodes with children ("folders") are sorted first.
+		if (a._has_children && !b._has_children) return -1
+		if (!a._has_children && b._has_children) return 1
+
+		// Otherwise sort by lowercased name.
+		const an = a.data.Name.toLowerCase()
+		const bn = b.data.Name.toLowerCase()
+		if (an < bn) return -1
+		if (an > bn) return 1
+		return 0
+	}//}}}
+	static create(name, parentUUID) {// {{{
+		const node = new Node({
+			UUID: uuidv7(),
+			Created: (new Date()).toISOString(),
+			Content: '',
+			Name: name,
+			ParentUUID: parentUUID,
+			Markdown: false,
+		})
+
+		// Newly created node (not constructed from existing data) is considered modified
+		// since node.save returns early if it isn't modified.
+		node._modified = true
+
+		return node
+	}// }}}
+
+	constructor(nodeData, level) {//{{{
+		this.Level = level
+		this.data = nodeData
+		this.UUID = nodeData.UUID
+
+		// Toplevel nodes are normalized to have the ROOT_NODE as parent.
+		if (nodeData.UUID !== ROOT_NODE && nodeData.ParentUUID === '') {
+			this.ParentUUID = ROOT_NODE
+			this.data.ParentUUID = ROOT_NODE
+		} else
+			this.ParentUUID = nodeData.ParentUUID
+
+		this._children_fetched = false
+		this._has_children = null // this will be set by nodeStore.getTreeNodes
+		this.Children = []
+		this.Ancestors = []
+
+		this._sibling_before = null
+		this._sibling_after = null
+		this._parent = null
+
+		this.reset()
+	}//}}}
+
+	reset() {// {{{
+		this._content = this.data.Content
+		this._modified = false
+	}// }}}
+	get(prop) {//{{{
+		return this.data[prop]
+	}//}}}
+	updated() {//{{{
+		// '2024-12-17T17:33:48.85939Z
+		return new Date(Date.parse(this.data.Updated))
+	}//}}}
+	isModified() {// {{{
+		return this._modified
+	}// }}}
+	hasFetchedChildren() {//{{{
+		return this._children_fetched
+	}//}}}
+	async fetchChildren() {//{{{
+		this.Children = await nodeStore.getTreeNodes(this.UUID, this.Level + 1)
+		this._children_fetched = true
+
+		// Children are sorted to allow for storing siblings befare and after.
+		// These are used with keyboard navigation in the tree.
+		this.Children.sort(Node.sort)
+
+		const numChildren = this.Children.length
+		this.setHasChildren(numChildren > 0)
+		for (let i = 0; i < numChildren; i++) {
+			if (i > 0)
+				this.Children[i]._sibling_before = this.Children[i - 1]
+			if (i < numChildren - 1)
+				this.Children[i]._sibling_after = this.Children[i + 1]
+			this.Children[i]._parent = this
+		}
+
+		return this.Children
+	}//}}}
+	setHasChildren(v) {// {{{
+		this._has_children = v
+	}// }}}
+	hasChildren() {//{{{
+		return this._has_children
+	}//}}}
+	getSiblingBefore() {// {{{
+		return this._sibling_before
+	}// }}}
+	getSiblingAfter() {// {{{
+		return this._sibling_after
+	}// }}}
+	getParent() {//{{{
+		return this._parent
+	}//}}}
+	moveToParent(newParentUUID) {// {{{
+		if (this.UUID === newParentUUID)
+			throw new Error("New parent UUID is the same as node UUID. Can't be your own parent.")
+
+		this.ParentUUID = newParentUUID
+		this.data.ParentUUID = newParentUUID
+		this._modified = true
+	}// }}}
+	isLastSibling() {//{{{
+		return this._sibling_after === null
+	}//}}}
+	isFirstSibling() {//{{{
+		return this._sibling_before === null
+	}//}}}
+	isSpecial() {// {{{
+		return this.data.Special
+	}// }}}
+	content() {//{{{
+		/* TODO - implement crypto
+		if (this.CryptoKeyID != 0 && !this._decrypted)
+			this.#decrypt()
+		*/
+		return this._content
+	}//}}}
+	setContent(new_content) {//{{{
+		this._content = new_content
+		this._modified = true
+		_mbus.dispatch('NODE_MODIFIED', { node: this })
+	}//}}}
+	setName(new_name) {// {{{
+		if (new_name.trim() === '')
+			throw new Error(`The name can't be empty`)
+
+		this.data.Name = new_name
+		this._modified = true
+		_mbus.dispatch('NODE_MODIFIED', { node: this })
+	}// }}}
+	async save() {//{{{
+		// Just safeguarding not using the root node,
+		// which sort of exist but isn't supposed to communicate to server.
+		if (this.UUID == ROOT_NODE)
+			return
+
+		this.data.Content = this._content
+		this.data.Updated = new Date().toISOString()
+		this.data.HistoryUUID = uuidv7() // every time the node is saved a new history UUID identifies the changed node.
+		this._modified = false
+
+		_mbus.dispatch('NODE_UNMODIFIED')
+
+		// When stored into database and ancestry was changed,
+		// the ancestry path could be interesting.
+		/*
+		const ancestors = await nodeStore.getNodeAncestry(this)
+		this.data.Ancestors = ancestors.map(a => a.get('Name')).reverse()
+		*/
+		/* The node history is a local store for node history.
+		 * This could be provisioned from the server or cleared if
+		 * deemed unnecessary.
+		 *
+		 * The send queue is what will be sent back to the server
+		 * to have a recorded history of the notes.
+		 *
+		 * A setting to be implemented in the future could be to
+		 * not save the history locally at all. */
+
+		// Current node is added to history. It will be duplicated with the "nodes" store
+		// for simplicity, to hopefully avoid bugs.
+		const history = nodeStore.nodesHistory.add(this)
+
+		// Updated node is added to the send queue to be stored on server.
+
+		const sendQueue = nodeStore.sendQueue.add(this)
+
+		// Updated node is saved to the primary node store.
+		const nodeStoreAdding = nodeStore.add([this])
+
+		console.log('waiting')
+		await Promise.all([history, sendQueue, nodeStoreAdding])
+		console.log('waiting done')
+
+		return
+	}//}}}
+}
+
+
 // vim: foldmethod=marker
diff --git a/static/js/page_preferences.mjs b/static/js/page_preferences.mjs
index dd85ebf..9655278 100644
--- a/static/js/page_preferences.mjs
+++ b/static/js/page_preferences.mjs
@@ -45,7 +45,7 @@ export class N2PagePreferences extends CustomHTMLElement {
 
 		this.elNewSet.addEventListener('click', () => this.newSet())
 		this.elSave.addEventListener('click', () => this.save())
-		this.elDevPreferenceSet.addEventListener('change', ()=>this.changePreferenceSet())
+		this.elDevPreferenceSet.addEventListener('change', event=>this.changePreferenceSet(event))
 
 		window._mbus.subscribe('SHOW_PAGE', async event => {
 			if (event.detail.data?.page == 'preferences') {
@@ -71,7 +71,7 @@ export class N2PagePreferences extends CustomHTMLElement {
 			this.sets.sort(this.sortSets)
 			this.elSets.replaceChildren(...this.sets)
 			
-			const setNames = this.sets.entries().map(([_idx, set]) => {
+			const setNames = this.sets.entries().map(([i, set]) => {
 				const optn = document.createElement('option')
 				optn.innerText = set.name
 				return optn
@@ -106,7 +106,7 @@ export class N2PagePreferences extends CustomHTMLElement {
 			alert(`Error retrieving preferences: ${e.message}`)
 		}
 	}// }}}
-	changePreferenceSet() {// {{{
+	changePreferenceSet(event) {// {{{
 		this.preferencesModified()
 	}// }}}
 	newSet() {// {{{
@@ -168,8 +168,6 @@ export class N2PagePreferences extends CustomHTMLElement {
 			user.Preferences = newPrefs
 			localStorage.setItem('user', JSON.stringify(user))
 			localStorage.setItem('device_preference_set', this.elDevPreferenceSet.value)
-
-			// Application is told that reloading preferences is to be done.
 			_mbus.dispatch('DEVICE_PREFERENCE_SET_UPDATED')
 		} catch (e) {
 			console.error(e)
diff --git a/static/js/page_storage.mjs b/static/js/page_storage.mjs
index 96f50ac..a007130 100644
--- a/static/js/page_storage.mjs
+++ b/static/js/page_storage.mjs
@@ -1,51 +1,17 @@
 import { CustomHTMLElement } from "./lib/custom_html_element.mjs"
-import { API } from 'api'
 
 export class N2PageStorage extends CustomHTMLElement {
 	static {
 		this.tmpl = document.createElement('template')
 		this.tmpl.innerHTML = `
-			<style>
-				.table {
-					display: grid;
-					grid-template-columns: min-content min-content;
-					grid-gap: 4px 16px;
-					align-items: center;
-					white-space: nowrap;
-				}
-
-				.error {
-					background-color: #ff2a2a;
-					color: #fff;
-					padding: 4px 8px;
-					border-radius: 4px;
-				}
-			</style>
-
 			<h1>Local storage</h1>
-			<div class="table">
-				<div>Local nodes</div>
-				<div data-el="count-nodes"></div>
-
-				<div>Queued to sync</div>
-				<div data-el="count-queued-nodes"></div>
-
-				<div>History nodes</div>
-				<div data-el="count-history-nodes"></div>
-			</div>
-
-			<h1>Files</h1>
-			<div class="table">
-				<div>Files on server</div>
-				<div data-el="count-files-on-server"></div>
-
-				<div>Files to send</div>
-				<div data-el="count-queued-files"></div>
-			</div>
+			<div data-el="count-nodes"></div>
+			<div data-el="count-queued-nodes"></div>
+			<div data-el="count-history-nodes"></div>
 		`
 	}
 	constructor() {
-		super(true)
+		super()
 
 		window._mbus.subscribe('SHOW_PAGE', event => {
 			if (event.detail.data?.page == 'storage')
@@ -53,21 +19,13 @@ export class N2PageStorage extends CustomHTMLElement {
 		})
 	}
 	async render() {
-		API.query('GET', '/file/count')
-			.then(res => {
-				this.elCountFilesOnServer.innerText = res.Count
-			})
-			.catch(err => {
-				this.elCountFilesOnServer.classList.add('error')
-				console.error(err)
-				this.elCountFilesOnServer.innerText = err.message
-			})
+		const countNodes = await globalThis.nodeStore.nodeCount()
+		const countQueuedNodes = await globalThis.nodeStore.sendQueue.count()
+		const countHistoryNodes = await globalThis.nodeStore.nodesHistory.count()
 
-
-		this.elCountNodes.innerText = await globalThis.nodeStore.nodeCount()
-		this.elCountQueuedNodes.innerText = await globalThis.nodeStore.sendQueue.count()
-		this.elCountHistoryNodes.innerText = await globalThis.nodeStore.nodesHistory.count()
-		this.elCountQueuedFiles.innerText = await globalThis.nodeStore.filesMetadata.countToUpload()
+		this.elCountNodes.innerText = countNodes
+		this.elCountQueuedNodes.innerText = countQueuedNodes
+		this.elCountHistoryNodes.innerText = countHistoryNodes
 	}
 }
 customElements.define('n2-pagestorage', N2PageStorage)
diff --git a/static/js/sidebar.mjs b/static/js/sidebar.mjs
index 899e955..6cd5814 100644
--- a/static/js/sidebar.mjs
+++ b/static/js/sidebar.mjs
@@ -1,4 +1,5 @@
-import { ROOT_NODE, ORPHANED_NODE, DELETED_NODE, Node } from 'node_store'
+import { ROOT_NODE, ORPHANED_NODE, DELETED_NODE } from 'node_store'
+import { Node } from 'node'
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
 import { Color, Solver } from './lib/css_colorize.mjs'
 
@@ -81,16 +82,11 @@ export class N2Sidebar extends CustomHTMLElement {
 
 					.icons {
 						display: flex;
-						justify-content: start;
+						justify-content: center;
 						margin-top: 16px;
-						gap: 8px 16px;
-						padding-left: 40px;
+						gap: 8px;
 						padding-bottom: 16px;
 						border-bottom: 1px solid var(--line-color);
-
-						img {
-							cursor: pointer;
-						}
 					}
 
 
@@ -108,7 +104,6 @@ export class N2Sidebar extends CustomHTMLElement {
 			</div>
 			<div class="icons">
 				<img data-el="sync"     class='sync colorize'     src="/images/${_VERSION}/icon_refresh.svg"  />
-				<img data-el="storage"  class='storage colorize'  src="/images/${_VERSION}/icon_storage.svg"  />
 				<img data-el="search"   class='search colorize'   src="/images/${_VERSION}/icon_search.svg" style="height: 22px" />
 				<img data-el="settings" class='settings colorize' src="/images/${_VERSION}/icon_settings.svg" />
 			</div>
@@ -132,7 +127,6 @@ export class N2Sidebar extends CustomHTMLElement {
 		this.addEventListener('keydown', event => this.keyHandler(event))
 		this.elSearch.addEventListener('click', () => _mbus.dispatch('op-search'))
 		this.elSync.addEventListener('click', () => _sync.run())
-		this.elStorage.addEventListener('click', () => _mbus.dispatch('SHOW_PAGE', { page: 'storage' }))
 		this.elLogo.addEventListener('click', () => _app.goToNode(ROOT_NODE, false, false))
 		this.elSettings.addEventListener('click', ()=> _mbus.dispatch('SHOW_PAGE', { page: 'preferences' }))
 		this.elHideTree.addEventListener('click', event => {
diff --git a/static/js/sync.mjs b/static/js/sync.mjs
index f68a09f..daa603f 100644
--- a/static/js/sync.mjs
+++ b/static/js/sync.mjs
@@ -1,5 +1,5 @@
 import { API } from 'api'
-import { Node } from 'node_store'
+import { Node } from 'node'
 import { CustomHTMLElement } from './lib/custom_html_element.mjs'
 
 export class Sync {
@@ -164,53 +164,6 @@ export class Sync {
 			}
 		}
 	}//}}}
-	async filesToServer() {// {{{
-		try {
-			const BLOCKSIZE = 128 * 1024
-			let sentBytes = 0
-
-			const metadata = await nodeStore.nextFileToSync()
-			if (metadata === null)
-				return
-
-			const stream = await globalThis.nodeStore.fileSegments.getStream(metadata.UUID)
-			const reader = stream.getReader({ mode: 'byob' }) // Bring Your Own Buffer
-			let buffer = new Uint8Array(BLOCKSIZE)
-
-			while (true) {
-				const { value, done } = await reader.read(buffer)
-
-				await API.upload(metadata.UUID, value, sentBytes, metadata)
-				metadata.setUploaded()
-				nodeStore.filesMetadata.add(metadata)
-
-				if (done)
-					break
-				sentBytes += value.length
-				buffer = new Uint8Array(value.buffer)
-			}
-			reader.releaseLock()
-		} catch (e) {
-			console.error(e)
-			alert(e.message)
-		}
-	}// }}}
-
-	async filesFromServer() {// {{{
-		let offset = 0
-		let more = true
-
-		try {
-			while (more) {
-				const res = await API.query('GET', `/file/server_uuids/${offset}`)
-				more = res.MoreRowsExist
-				console.log(res)
-			}
-		} catch (e) {
-			console.error(e)
-			alert(e.message)
-		}
-	}// }}}
 }
 
 export class N2SyncProgress extends CustomHTMLElement {
diff --git a/static/service_worker.js b/static/service_worker.js
index 7cf268e..8522b20 100644
--- a/static/service_worker.js
+++ b/static/service_worker.js
@@ -1,5 +1,3 @@
-import { NodeStore } from '/js/{{ .VERSION }}/node_store.mjs'
-
 const CACHE_NAME = 'notes2-{{ .VERSION }}'
 const CACHED_ASSETS = [
 	'/',
@@ -13,21 +11,16 @@ const CACHED_ASSETS = [
 
 	'/images/{{ .VERSION }}/collapsed.svg',
 	'/images/{{ .VERSION }}/expanded.svg',
-	'/images/{{ .VERSION }}/icon_back.svg',
 	'/images/{{ .VERSION }}/icon_history.svg',
 	'/images/{{ .VERSION }}/icon_home.svg',
 	'/images/{{ .VERSION }}/icon_markdown_hollow.svg',
 	'/images/{{ .VERSION }}/icon_markdown.svg',
-	'/images/{{ .VERSION }}/icon_menu.svg',
-	'/images/{{ .VERSION }}/icon_new_document.svg',
 	'/images/{{ .VERSION }}/icon_refresh.svg',
 	'/images/{{ .VERSION }}/icon_save_disabled.svg',
 	'/images/{{ .VERSION }}/icon_save.svg',
 	'/images/{{ .VERSION }}/icon_search.svg',
 	'/images/{{ .VERSION }}/icon_settings.svg',
-	'/images/{{ .VERSION }}/icon_storage.svg',
 	'/images/{{ .VERSION }}/icon_table.svg',
-	'/images/{{ .VERSION }}/icon_transfer.svg',
 	'/images/{{ .VERSION }}/leaf.svg',
 	'/images/{{ .VERSION }}/logo_small.svg',
 	'/images/{{ .VERSION }}/logo.svg',
@@ -35,18 +28,20 @@ const CACHED_ASSETS = [
 	'/js/{{ .VERSION }}/api.mjs',
 	'/js/{{ .VERSION }}/app.mjs',
 	'/js/{{ .VERSION }}/checklist.mjs',
+	'/js/{{ .VERSION }}/crypto.mjs',
 	'/js/{{ .VERSION }}/file.mjs',
+	'/js/{{ .VERSION }}/key.mjs',
 	'/js/{{ .VERSION }}/lib/css_colorize.mjs',
 	'/js/{{ .VERSION }}/lib/custom_html_element.mjs',
 	'/js/{{ .VERSION }}/lib/node_modules/marked/lib/marked.esm.js',
 	'/js/{{ .VERSION }}/lib/node_modules/marked-token-position/lib/index.esm.js',
+	'/js/{{ .VERSION }}/lib/sjcl.js',
 	'/js/{{ .VERSION }}/marked_position.mjs',
 	'/js/{{ .VERSION }}/mbus.mjs',
 	'/js/{{ .VERSION }}/node_store.mjs',
 	'/js/{{ .VERSION }}/notes2.mjs',
 	'/js/{{ .VERSION }}/page_history.mjs',
 	'/js/{{ .VERSION }}/page_node.mjs',
-	'/js/{{ .VERSION }}/page_preferences.mjs',
 	'/js/{{ .VERSION }}/page_storage.mjs',
 	'/js/{{ .VERSION }}/sidebar.mjs',
 	'/js/{{ .VERSION }}/sync.mjs',
@@ -125,55 +120,14 @@ self.addEventListener('activate', event => {
 })
 
 self.addEventListener('fetch', event => {
-	const url = new URL(event.request.url)
-
 	// The fetch event is also seeing requests to other domains.
 	// Just let the browser handle those for itself.
-	const ourDomain = (url.host == self.location.host)
+	const ourDomain = event.request.url.startsWith(self.location.origin)
 	if (!ourDomain)
 		return event
 
-	if (url.pathname == '/stream-local') {
-		event.respondWith(indexeddbFile(event))
-		return
-	}
-
 	if (`{{ .DevMode }}` == 'true')
 		return event
-	else
-		event.respondWith(fetchAsset(event))
+
+	event.respondWith(fetchAsset(event))
 })
-
-
-let nodestore = null
-async function getNodestore() {
-	if (nodestore)
-		return nodestore
-
-	// When setting nodestore directly, then waiting on initializeDB,
-	// a second call for getNodestore can return the nodestore before
-	// initialized.
-	const initializingNodeStore = new NodeStore()
-	await initializingNodeStore.initializeDB()
-	nodestore = initializingNodeStore
-	return nodestore
-}
-
-async function indexeddbFile(event) {
-	const url = new URL(event.request.url)
-	const uuid = url.searchParams.get('uuid')
-
-	try {
-		const nodeStore = await getNodestore()
-		const md = await nodeStore.filesMetadata.get(uuid)
-		const stream = await nodeStore.fileSegments.getStream(uuid)
-
-		return new Response(stream, {
-			headers: {
-				'Content-Type': md.type,
-			}
-		})
-	} catch (err) {
-		console.error(err)
-	}
-}
diff --git a/views/layouts/main.gotmpl b/views/layouts/main.gotmpl
index 13a0bcf..c5fbead 100644
--- a/views/layouts/main.gotmpl
+++ b/views/layouts/main.gotmpl
@@ -9,8 +9,10 @@
 		{
 			"imports": {
 				"api":        "/js/{{ .VERSION }}/api.mjs",
-				"sync":       "/js/{{ .VERSION }}/sync.mjs",
+				"sync":        "/js/{{ .VERSION }}/sync.mjs",
+				"key":        "/js/{{ .VERSION }}/key.mjs",
 				"checklist":  "/js/{{ .VERSION }}/checklist.mjs",
+				"crypto":     "/js/{{ .VERSION }}/crypto.mjs",
 				"node_store": "/js/{{ .VERSION }}/node_store.mjs",
 				"node":       "/js/{{ .VERSION }}/page_node.mjs",
 				"sidebar":    "/js/{{ .VERSION }}/sidebar.mjs"
@@ -18,14 +20,14 @@
 		}
 		</script>
 		<script>
-			globalThis._VERSION = "{{ .VERSION }}"
+			window._VERSION = "{{ .VERSION }}"
 
 			if (navigator.serviceWorker)
-				navigator.serviceWorker.register('/service_worker.js', { type: 'module' })
+				navigator.serviceWorker.register('/service_worker.js')
 		</script>
 		<script type="module" defer>
 			import { MessageBus } from '/js/{{ .VERSION }}/mbus.mjs'
-			globalThis._mbus = new MessageBus()
+			window._mbus = new MessageBus()
 		</script>
 	</head>
 	<body>
diff --git a/views/pages/login.gotmpl b/views/pages/login.gotmpl
index 8e824aa..3e2235f 100644
--- a/views/pages/login.gotmpl
+++ b/views/pages/login.gotmpl
@@ -4,7 +4,7 @@
 	<img id="logo" src="/images/v1/logo.svg">
 	<input type="text" id="username" placeholder="Username">
 	<input type="password" id="password" placeholder="Password">
-	<button onclick="globalThis._login.authenticate()">Log in</button>
+	<button onclick=window._login.authenticate()>Log in</button>
 	<div id="error"></div>
 </div>
 
@@ -42,6 +42,6 @@ class Login {
 	}
 }
 
-globalThis._login = new Login()
+window._login = new Login()
 </script>
 {{ end }}
diff --git a/views/pages/notes2.gotmpl b/views/pages/notes2.gotmpl
index c5df63e..2755aea 100644
--- a/views/pages/notes2.gotmpl
+++ b/views/pages/notes2.gotmpl
@@ -7,7 +7,7 @@
 
 <!-- page-node -->
 <div id="notes2" class="page-node">
-	<div id="tree-expander" onclick="globalThis._mbus.dispatch('TREE_EXPANSION', { expand: true })">&gt;</div>
+	<div id="tree-expander" onclick="window._mbus.dispatch('TREE_EXPANSION', { expand: true })">&gt;</div>
 	<div id="tree" tabindex=0></div>
 
 	<div id="main-page">
@@ -47,21 +47,20 @@
 	import {App} from "/js/{{ .VERSION }}/app.mjs"
 	import {API} from 'api'
 	import {Sync} from 'sync'
-	import { } from '/js/{{ .VERSION }}/page_node.mjs'
 	import { } from '/js/{{ .VERSION }}/page_preferences.mjs'
 	import { } from '/js/{{ .VERSION }}/page_storage.mjs'
 	import { } from '/js/{{ .VERSION }}/page_history.mjs'
 	import { } from '/js/{{ .VERSION }}/file.mjs'
 
-	globalThis.Sync = Sync
+	window.Sync = Sync
 
 	if (!API.hasAuthenticationToken()) {
 		location.href = '/login'
 	} else {
 		try {
-			globalThis.nodeStore = new NodeStore()
-			globalThis.nodeStore.initializeDB().then(() => {
-				globalThis._app = new App()
+			window.nodeStore = new NodeStore()
+			window.nodeStore.initializeDB().then(() => {
+				window._app = new App()
 			})
 		} catch (e) {
 			alert(e)
diff --git a/views/pages/sync.gotmpl b/views/pages/sync.gotmpl
index c9fa870..eb79c77 100644
--- a/views/pages/sync.gotmpl
+++ b/views/pages/sync.gotmpl
@@ -5,9 +5,9 @@
 	<script type="module">
 		import { NodeStore } from 'node_store'
 		import { Sync } from 'sync'
-		globalThis.Sync = Sync
-		globalThis.nodeStore = new NodeStore()
-		globalThis.nodeStore.initializeDB().then(()=>{
+		window.Sync = Sync
+		window.nodeStore = new NodeStore()
+		window.nodeStore.initializeDB().then(()=>{
 			Sync.tree()
 		})
 	</script>