사소한 리팩토링

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.dockerignore

@@ -12,8 +12,6 @@ node_modules
 /data
 /library
 /thumbnails
-/uploads
-/log
 
 # OS
 .DS_Store
@@ -32,3 +30,6 @@ Thumbs.db
 # Vite
 vite.config.js.timestamp-*
 vite.config.ts.timestamp-*
+
+# E2E tests
+/test/e2e/results

.env.example

@@ -12,4 +12,3 @@ USER_CLIENT_CHALLENGE_EXPIRES=
 SESSION_UPGRADE_CHALLENGE_EXPIRES=
 LIBRARY_PATH=
 THUMBNAILS_PATH=
-UPLOADS_PATH=

.gitignore

@@ -10,8 +10,6 @@ node_modules
 /data
 /library
 /thumbnails
-/uploads
-/log
 
 # OS
 .DS_Store
@@ -30,3 +28,6 @@ Thumbs.db
 # Vite
 vite.config.js.timestamp-*
 vite.config.ts.timestamp-*
+
+# E2E tests
+/test/e2e/results

.prettierrc

@@ -1,6 +1,7 @@
 {
   "printWidth": 100,
   "plugins": ["prettier-plugin-svelte", "prettier-plugin-tailwindcss"],
+  "tailwindStylesheet": "./src/app.css",
   "overrides": [
     {
       "files": "*.svelte",

Dockerfile

@@ -2,8 +2,8 @@
 FROM node:22-alpine AS base
 WORKDIR /app
 
-RUN npm install -g pnpm@10
+RUN npm install -g pnpm@12
-COPY pnpm-lock.yaml .
+COPY pnpm-lock.yaml pnpm-workspace.yaml ./
 
 # Build Stage
 FROM base AS build

docker-compose.yaml

@@ -9,8 +9,6 @@ services:
     volumes:
       - ./data/library:/app/data/library
       - ./data/thumbnails:/app/data/thumbnails
-      - ./data/uploads:/app/data/uploads
-      - ./data/log:/app/data/log
     environment:
       # ArkVault
       - DATABASE_HOST=database
@@ -22,8 +20,6 @@ services:
       - SESSION_UPGRADE_CHALLENGE_EXPIRES
       - LIBRARY_PATH=/app/data/library
       - THUMBNAILS_PATH=/app/data/thumbnails
-      - UPLOADS_PATH=/app/data/uploads
-      - LOG_DIR=/app/data/log
       # SvelteKit
       - ADDRESS_HEADER=${TRUST_PROXY:+X-Forwarded-For}
       - XFF_DEPTH=${TRUST_PROXY:-}

eslint.config.js

@@ -1,5 +1,6 @@
 import { includeIgnoreFile } from "@eslint/compat";
 import js from "@eslint/js";
+import { loadConfig } from "@sveltejs/load-config";
 import { defineConfig } from "eslint/config";
 import prettier from "eslint-config-prettier";
 import svelte from "eslint-plugin-svelte";
@@ -7,16 +8,31 @@ import tailwind from "eslint-plugin-tailwindcss";
 import globals from "globals";
 import ts from "typescript-eslint";
 import { fileURLToPath } from "url";
-import svelteConfig from "./svelte.config.js";
+
+const svelteConfig = (await loadConfig("./", { traverse: false }))?.config;
 
 const gitignorePath = fileURLToPath(new URL("./.gitignore", import.meta.url));
 
+// Restricts the direction of dependencies between modules
+const defineImportBoundaries = (boundaries) =>
+  Object.entries(boundaries).map(([files, regex]) => ({
+    files: [files],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [{ regex, message: "Violates the dependency direction between modules." }],
+        },
+      ],
+    },
+  }));
+
 export default defineConfig(
   includeIgnoreFile(gitignorePath),
   js.configs.recommended,
   ...ts.configs.recommended,
   ...svelte.configs.recommended,
-  ...tailwind.configs["flat/recommended"],
+  tailwind.configs.recommended,
   prettier,
   ...svelte.configs.prettier,
   {
@@ -26,10 +42,27 @@ export default defineConfig(
         ...globals.node,
       },
     },
+    settings: {
+      tailwindcss: {
+        cssConfigPath: "./src/app.css",
+      },
+    },
     rules: {
       "no-undef": "off",
     },
   },
+  ...defineImportBoundaries({
+    // Pure code shared by the server, the client, and the service worker
+    "src/lib/shared/**": "^(#lib/(?!shared/)|#trpc/|#workers/|\\$app/|svelte($|/))",
+    "src/lib/server/**": "^(#lib/(client|features|ui)/|#trpc/)",
+    // Infrastructure of the browser
+    "src/lib/client/**": "^#lib/(server|features|ui)/",
+    // Domain-agnostic components
+    "src/lib/ui/**": "^(#lib/(server|client|features)/|#trpc/)",
+    "src/lib/features/**": "^#lib/server/",
+    "src/service-worker/**":
+      "^(#lib/(?!shared/|client/storage/|client/cache/file-cache\\.ts$)|#trpc/|#workers/)",
+  }),
   {
     files: ["**/*.svelte", "**/*.svelte.ts", "**/*.svelte.js"],
     languageOptions: {

kysely.config.ts

@@ -1,17 +1,17 @@
 import { defineConfig } from "kysely-ctl";
-import { Pool } from "pg";
+import { createDialect } from "./src/lib/server/db/dialect.ts";
+
+// Empty values (e.g. `DATABASE_HOST=` in .env) are treated as unset, as in src/env.ts
+const optional = (name: string) => process.env[name] || undefined;
 
 export default defineConfig({
-  dialect: "pg",
+  dialect: createDialect({
-  dialectConfig: {
+    host: optional("DATABASE_HOST"),
-    pool: new Pool({
+    port: optional("DATABASE_PORT") ? Number(optional("DATABASE_PORT")) : undefined,
-      host: process.env.DATABASE_HOST,
+    user: optional("DATABASE_USER"),
-      port: process.env.DATABASE_PORT ? parseInt(process.env.DATABASE_PORT) : undefined,
+    password: optional("DATABASE_PASSWORD"),
-      user: process.env.DATABASE_USER,
+    name: optional("DATABASE_NAME"),
-      password: process.env.DATABASE_PASSWORD,
+  }),
-      database: process.env.DATABASE_NAME,
-    }),
-  },
   migrations: {
     migrationFolder: "./src/lib/server/db/migrations",
   },

package.json

@@ -1,74 +1,86 @@
 {
   "name": "arkvault",
   "private": true,
-  "version": "0.9.0",
+  "version": "0.9.1",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
+    "dev:remote": "__VITE_ADDITIONAL_SERVER_ALLOWED_HOSTS=.ts.net vite dev --host 0.0.0.0",
     "build": "vite build",
     "preview": "vite preview",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json && tsc --noEmit --project ./src/service-worker",
     "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
     "format": "prettier --write .",
     "lint": "prettier --check . && eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "bash test/e2e/run.sh",
     "db:up": "docker compose -f docker-compose.dev.yaml -p arkvault-dev up -d",
     "db:down": "docker compose -f docker-compose.dev.yaml -p arkvault-dev down",
     "db:migrate": "kysely migrate"
   },
   "devDependencies": {
-    "@eslint/compat": "^2.0.1",
+    "@eslint/compat": "^2.1.1",
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^10.0.1",
-    "@iconify-json/material-symbols": "^1.2.51",
+    "@iconify-json/material-symbols": "^1.2.95",
-    "@noble/hashes": "^2.0.1",
+    "@noble/hashes": "^2.4.0",
-    "@sveltejs/adapter-node": "^5.5.1",
+    "@playwright/test": "1.64.0",
-    "@sveltejs/kit": "^2.49.5",
+    "@sveltejs/adapter-node": "^6.0.0",
-    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@sveltejs/kit": "^3.0.1",
-    "@tanstack/svelte-virtual": "^3.13.18",
+    "@sveltejs/load-config": "^0.2.2",
-    "@trpc/client": "^11.8.1",
+    "@sveltejs/vite-plugin-svelte": "^7.3.1",
+    "@tailwindcss/vite": "^4.3.3",
+    "@tanstack/svelte-virtual": "^3.13.40",
+    "@testcontainers/postgresql": "^12.2.0",
+    "@trpc/client": "^11.19.0",
     "@types/file-saver": "^2.0.7",
-    "@types/ms": "^0.7.34",
+    "@types/ms": "^2.1.0",
     "@types/node-schedule": "^2.1.8",
-    "@types/pg": "^8.16.0",
+    "@types/pg": "^8.23.1",
-    "autoprefixer": "^10.4.23",
+    "axios": "^1.20.0",
-    "axios": "^1.13.2",
+    "dexie": "^4.4.6",
-    "dexie": "^4.2.1",
+    "es-hangul": "^2.4.0",
-    "es-hangul": "^2.3.8",
+    "eslint": "^10.12.0",
-    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-svelte": "^3.14.0",
+    "eslint-plugin-svelte": "^3.23.1",
-    "eslint-plugin-tailwindcss": "^3.18.2",
+    "eslint-plugin-tailwindcss": "^4.4.0",
-    "exifreader": "^4.36.0",
+    "exifreader": "^4.48.0",
     "file-saver": "^2.0.5",
-    "globals": "^17.0.0",
+    "globals": "^17.13.0",
     "heic2any": "^0.0.4",
-    "kysely-ctl": "^0.20.0",
+    "kysely-ctl": "^0.21.0",
-    "lru-cache": "^11.2.4",
+    "lru-cache": "^11.5.3",
     "mime": "^4.1.0",
-    "p-limit": "^7.2.0",
+    "p-limit": "^7.3.3",
-    "prettier": "^3.8.0",
+    "prettier": "^3.9.10",
-    "prettier-plugin-svelte": "^3.4.1",
+    "prettier-plugin-svelte": "^4.1.1",
-    "prettier-plugin-tailwindcss": "^0.7.2",
+    "prettier-plugin-tailwindcss": "^0.8.1",
-    "svelte": "^5.46.4",
+    "svelte": "^5.57.2",
-    "svelte-check": "^4.3.5",
+    "svelte-check": "^4.7.6",
-    "tailwindcss": "^3.4.19",
+    "tailwindcss": "^4.3.3",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.53.0",
+    "typescript-eslint": "^8.71.1",
-    "unplugin-icons": "^23.0.1",
+    "unplugin-icons": "^24.0.0",
-    "vite": "^7.3.1"
+    "vite": "^8.3.4",
+    "vitest": "^5.0.3"
   },
   "dependencies": {
-    "@trpc/server": "^11.8.1",
+    "@trpc/server": "^11.19.0",
-    "argon2": "^0.44.0",
+    "argon2": "^0.45.1",
-    "kysely": "^0.28.9",
+    "kysely": "^0.29.6",
     "ms": "^2.1.3",
     "node-schedule": "^2.1.1",
-    "pg": "^8.17.1",
+    "pg": "^8.23.1",
     "superjson": "^2.2.6",
-    "uuid": "^13.0.0",
+    "zod": "^4.6.5"
-    "zod": "^4.3.5"
   },
   "engines": {
-    "node": "^22.0.0",
+    "node": "^22.17.0",
-    "pnpm": "^10.0.0"
+    "pnpm": "^12.0.0"
+  },
+  "imports": {
+    "#lib/*": "./src/lib/*",
+    "#trpc/*": "./src/trpc/*",
+    "#workers/*": "./src/workers/*"
   }
 }

pnpm-workspace.yaml

@@ -0,0 +1,6 @@
+allowBuilds:
+  argon2: true
+  cpu-features: false
+  exifreader: false
+  protobufjs: false
+  ssh2: false

postcss.config.js

@@ -1,6 +0,0 @@
-export default {
-  plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-};

src/app.css

@@ -1,3 +1,48 @@
-@import "tailwindcss/base";
+@import "tailwindcss";
-@import "tailwindcss/components";
+
-@import "tailwindcss/utilities";
+@theme {
+  --color-primary-100: #ffe3e3;
+  --color-primary-200: #ffc9c9;
+  --color-primary-300: #ffa8a8;
+  --color-primary-400: #ff8787;
+  --color-primary-500: #ff6b6b;
+  --color-primary-600: #fa5252;
+  --color-primary-700: #f03e3e;
+  --color-primary-800: #e03131;
+  --color-primary-900: #c92a2a;
+  --color-primary-000: #fff5f5;
+
+  --color-gray-100: #f1f3f5;
+  --color-gray-200: #e9ecef;
+  --color-gray-300: #dee2e6;
+  --color-gray-400: #ced4da;
+  --color-gray-500: #adb5bd;
+  --color-gray-600: #868e96;
+  --color-gray-700: #495057;
+  --color-gray-800: #343a40;
+  --color-gray-900: #212529;
+  --color-gray-000: #f8f9fa;
+
+  --font-sans:
+    "Pretendard Variable", Pretendard, -apple-system, BlinkMacSystemFont, system-ui, Roboto,
+    "Helvetica Neue", "Segoe UI", "Apple SD Gothic Neo", "Noto Sans KR", "Malgun Gothic",
+    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", sans-serif;
+}
+
+/*
+  The default border color has changed to `currentcolor` in Tailwind CSS v4,
+  so we've added these compatibility styles to make sure everything still
+  looks the same as it did with Tailwind CSS v3.
+
+  If we ever want to remove these styles, we need to add an explicit border
+  color utility to any element that depends on these defaults.
+*/
+@layer base {
+  *,
+  ::after,
+  ::before,
+  ::backdrop,
+  ::file-selector-button {
+    border-color: var(--color-gray-200, currentcolor);
+  }
+}

src/env.ts

@@ -0,0 +1,45 @@
+import { building } from "$app/env";
+import { defineEnvVars } from "@sveltejs/kit/env";
+import ms, { type StringValue } from "ms";
+
+// Empty values (e.g. `LIBRARY_PATH=` in .env) are treated as unset
+
+const required = (value: string | undefined) => {
+  if (!value && !building) throw new Error("Required environment variable not set");
+  return value ?? "";
+};
+
+const optional = (value: string | undefined) => value || undefined;
+
+const withDefault = (defaultValue: string) => (value: string | undefined) => value || defaultValue;
+
+const duration = (defaultValue: StringValue) => (value: string | undefined) => {
+  const result = ms((value || defaultValue) as StringValue);
+  if (!Number.isFinite(result)) throw new Error(`Invalid duration: ${value}`);
+  return result;
+};
+
+export const variables = defineEnvVars({
+  NODE_ENV: { schema: withDefault("development") },
+
+  DATABASE_HOST: { schema: optional },
+  DATABASE_PORT: {
+    schema: (value) => {
+      if (!value) return undefined;
+      const port = Number(value);
+      if (!Number.isInteger(port)) throw new Error(`Invalid port: ${value}`);
+      return port;
+    },
+  },
+  DATABASE_USER: { schema: optional },
+  DATABASE_PASSWORD: { schema: required },
+  DATABASE_NAME: { schema: optional },
+
+  SESSION_SECRET: { schema: required },
+  SESSION_EXPIRES: { schema: duration("14d") },
+  USER_CLIENT_CHALLENGE_EXPIRES: { schema: duration("5m") },
+  SESSION_UPGRADE_CHALLENGE_EXPIRES: { schema: duration("5m") },
+
+  LIBRARY_PATH: { schema: withDefault("library") },
+  THUMBNAILS_PATH: { schema: withDefault("thumbnails") },
+});

src/hooks.client.ts

@@ -1,7 +1,8 @@
-import type { ClientInit } from "@sveltejs/kit";
+import type { ClientInit } from "@sveltejs/kit/hooks";
-import { cleanupDanglingInfos, getClientKey, getMasterKeys, getHmacSecrets } from "$lib/indexedDB";
+import { cleanupFileCaches } from "#lib/client/cache/index.ts";
-import { prepareFileCache } from "$lib/modules/file";
+import { keyring } from "#lib/client/keys/index.ts";
-import { clientKeyStore, masterKeyStore, hmacSecretStore } from "$lib/stores";
+import { listenForServiceWorkerMessages } from "#lib/client/service-worker.ts";
+import { cleanupDanglingInfos } from "#lib/client/storage/indexed-db/index.ts";
 
 const requestPersistentStorage = async () => {
   const isPersistent = await navigator.storage.persist();
@@ -12,40 +13,11 @@ const requestPersistentStorage = async () => {
   }
 };
 
-const prepareClientKeyStore = async () => {
-  const [encryptKey, decryptKey, signKey, verifyKey] = await Promise.all([
-    getClientKey("encrypt"),
-    getClientKey("decrypt"),
-    getClientKey("sign"),
-    getClientKey("verify"),
-  ]);
-  if (encryptKey && decryptKey && signKey && verifyKey) {
-    clientKeyStore.set({ encryptKey, decryptKey, signKey, verifyKey });
-  }
-};
-
-const prepareMasterKeyStore = async () => {
-  const masterKeys = await getMasterKeys();
-  if (masterKeys.length > 0) {
-    masterKeyStore.set(new Map(masterKeys.map((masterKey) => [masterKey.version, masterKey])));
-  }
-};
-
-const prepareHmacSecretStore = async () => {
-  const hmacSecrets = await getHmacSecrets();
-  if (hmacSecrets.length > 0) {
-    hmacSecretStore.set(new Map(hmacSecrets.map((hmacSecret) => [hmacSecret.version, hmacSecret])));
-  }
-};
-
 export const init: ClientInit = async () => {
-  await Promise.all([
+  listenForServiceWorkerMessages();
-    requestPersistentStorage(),
+
-    prepareFileCache(),
+  await Promise.all([requestPersistentStorage(), keyring.load()]);
-    prepareClientKeyStore(),
-    prepareMasterKeyStore(),
-    prepareHmacSecretStore(),
-  ]);
 
   cleanupDanglingInfos(); // Intended
+  cleanupFileCaches().catch(console.error);
 };

src/hooks.server.ts

@@ -1,24 +1,30 @@
-import type { ServerInit } from "@sveltejs/kit";
+import { sequence, type ServerInit } from "@sveltejs/kit/hooks";
-import { sequence } from "@sveltejs/kit/hooks";
 import schedule from "node-schedule";
-import { cleanupExpiredUserClientChallenges } from "$lib/server/db/client";
+import { migrateDB } from "#lib/server/db/kysely.ts";
-import { migrateDB } from "$lib/server/db/kysely";
+import { authenticate, setAgentInfo } from "#lib/server/middlewares/index.ts";
 import {
-  cleanupExpiredSessions,
+  AuthService,
-  cleanupExpiredSessionUpgradeChallenges,
+  ClientService,
-} from "$lib/server/db/session";
+  FileDeletionService,
-import { authenticate, setAgentInfo } from "$lib/server/middlewares";
+  UploadService,
-import { cleanupExpiredUploadSessions } from "$lib/server/services/upload";
+} from "#lib/server/services/index.ts";
 
 export const init: ServerInit = async () => {
   await migrateDB();
 
-  schedule.scheduleJob("0 * * * *", () => {
+  schedule.scheduleJob("0 * * * *", async () => {
-    cleanupExpiredUserClientChallenges();
+    // Failures are logged and retried at the next run, so they don't crash the server
-    cleanupExpiredSessions();
+    const results = await Promise.allSettled([
-    cleanupExpiredSessionUpgradeChallenges();
+      AuthService.cleanupExpiredSessions(),
-    cleanupExpiredUploadSessions();
+      ClientService.cleanupExpiredChallenges(),
+      UploadService.cleanupExpiredUploadSessions(),
+    ]);
+    results.forEach((result) => {
+      if (result.status === "rejected") console.error(result.reason);
+    });
+    FileDeletionService.schedulePendingFileDeletions();
   });
+  FileDeletionService.schedulePendingFileDeletions();
 };
 
 export const handle = sequence(setAgentInfo, authenticate);

src/lib/client/cache/file-cache.ts

@@ -0,0 +1,185 @@
+import {
+  deleteFileCacheIndex,
+  getFileCacheIndex as getAllFileCacheIndexes,
+  getFileCacheIndexOf,
+  storeFileCacheIndex,
+  updateFileCacheRetrievedAt,
+} from "#lib/client/storage/indexed-db/cache-index.ts";
+import {
+  createWritable,
+  deleteDirectory,
+  deleteFile,
+  deleteFilesInDirectory,
+  getFile,
+  listDirectoryNames,
+  listFileNames,
+  moveFile,
+} from "#lib/client/storage/opfs.ts";
+import { CHUNK_SIZE, getChunkCount } from "#lib/shared/format/index.ts";
+
+// Caches the plaintext of files in chunks, so that partially loaded files (e.g. videos which were
+// partially played) can also be cached. Chunk `i` starts at `i * CHUNK_SIZE` of the plaintext,
+// except that legacy files are cached as a single chunk. Used by both the pages and the service
+// worker, so the index is always read from IndexedDB.
+
+export interface FileCacheLayout {
+  totalSize: number;
+  chunkCount: number;
+}
+
+const getDirectoryPath = (fileId: number) => `/cache/file/${fileId}`;
+const getChunkPath = (fileId: number, chunkIndex: number) =>
+  `${getDirectoryPath(fileId)}/${chunkIndex}`;
+
+const getChunkSize = ({ totalSize, chunkCount }: FileCacheLayout, chunkIndex: number) => {
+  return chunkCount === 1 ? totalSize : Math.min(CHUNK_SIZE, totalSize - chunkIndex * CHUNK_SIZE);
+};
+
+export const getFileCacheIndex = async () => {
+  return await getAllFileCacheIndexes();
+};
+
+export const getCachedChunkIndexes = async (fileId: number) => {
+  const names = await listFileNames(getDirectoryPath(fileId));
+  return new Set(names.filter((name) => /^\d+$/.test(name)).map(Number));
+};
+
+export const readCachedChunk = async (fileId: number, chunkIndex: number) => {
+  return await getFile(getChunkPath(fileId, chunkIndex));
+};
+
+export const touchFileCache = async (fileId: number) => {
+  await updateFileCacheRetrievedAt(fileId, new Date());
+};
+
+const updateIndex = async (fileId: number, layout: FileCacheLayout) => {
+  const chunkIndexes = await getCachedChunkIndexes(fileId);
+  const size = chunkIndexes
+    .values()
+    .filter((chunkIndex) => chunkIndex < layout.chunkCount)
+    .reduce((size, chunkIndex) => size + getChunkSize(layout, chunkIndex), 0);
+  const now = new Date();
+
+  await storeFileCacheIndex({
+    fileId,
+    cachedAt: (await getFileCacheIndexOf(fileId))?.cachedAt ?? now,
+    lastRetrievedAt: now,
+    size,
+    totalSize: layout.totalSize,
+    chunkCount: layout.chunkCount,
+    isComplete: size === layout.totalSize,
+  });
+};
+
+// Writes of the same file are serialized so that the index isn't updated with a stale state
+const writeQueues = new Map<number, Promise<unknown>>();
+
+const enqueueWrite = <T>(fileId: number, write: () => Promise<T>) => {
+  const result = (writeQueues.get(fileId) ?? Promise.resolve()).catch(() => {}).then(write);
+  const settled = result.catch(() => {});
+  writeQueues.set(fileId, settled);
+  void settled.then(() => {
+    if (writeQueues.get(fileId) === settled) {
+      writeQueues.delete(fileId);
+    }
+  });
+  return result;
+};
+
+export const storeCachedChunk = (
+  fileId: number,
+  chunkIndex: number,
+  data: Uint8Array | Blob,
+  layout: FileCacheLayout,
+) => enqueueWrite(fileId, () => writeChunk(fileId, chunkIndex, data, layout));
+
+const writeChunk = async (
+  fileId: number,
+  chunkIndex: number,
+  data: Uint8Array | Blob,
+  layout: FileCacheLayout,
+) => {
+  const path = getChunkPath(fileId, chunkIndex);
+  const tempPath = `${path}.${crypto.randomUUID()}.tmp`;
+
+  // Written to a temporary file first, so that incomplete chunks are never visible
+  const writable = await createWritable(tempPath);
+  try {
+    await writable.write(data as FileSystemWriteChunkType);
+    await writable.close();
+    await moveFile(tempPath, path);
+  } catch (e) {
+    await writable.abort().catch(() => {});
+    await deleteFile(tempPath).catch(() => {});
+    throw e;
+  }
+
+  await updateIndex(fileId, layout);
+};
+
+const UPLOAD_CACHE_DIRECTORY = "/cache/upload";
+const STALE_UPLOAD_CACHE_AGE = 24 * 3600 * 1000; // 24 hours
+
+// Caches the plaintext of a file while it is being uploaded. Chunks are written to a temporary
+// directory, and moved to the cache once the id of the file is known.
+export const createUploadFileCache = (totalSize: number) => {
+  const layout = { totalSize, chunkCount: getChunkCount(totalSize) };
+  // Prefixed with the creation time to find stale ones (e.g. the tab was closed while uploading)
+  const directoryPath = `${UPLOAD_CACHE_DIRECTORY}/${Date.now()}-${crypto.randomUUID()}`;
+  const writtenChunkIndexes = new Set<number>();
+  let isFailed = false;
+
+  const discard = async () => {
+    isFailed = true;
+    await deleteDirectory(directoryPath).catch(() => {});
+  };
+
+  return {
+    // Failing to cache shouldn't fail the upload, so errors are ignored
+    async writeChunk(chunkIndex: number, data: ArrayBuffer) {
+      if (isFailed) return;
+
+      try {
+        const writable = await createWritable(`${directoryPath}/${chunkIndex}`);
+        await writable.write(data);
+        await writable.close();
+        writtenChunkIndexes.add(chunkIndex);
+      } catch (e) {
+        console.error(e);
+        await discard();
+      }
+    },
+    async commit(fileId: number) {
+      if (isFailed || writtenChunkIndexes.size !== layout.chunkCount) {
+        await discard();
+        return;
+      }
+
+      await enqueueWrite(fileId, async () => {
+        for (const chunkIndex of writtenChunkIndexes) {
+          await moveFile(`${directoryPath}/${chunkIndex}`, getChunkPath(fileId, chunkIndex));
+        }
+        await updateIndex(fileId, layout);
+      }).finally(discard);
+    },
+    discard,
+  };
+};
+
+export const deleteFileCache = async (fileId: number) => {
+  await deleteFileCacheIndex(fileId);
+  await deleteDirectory(getDirectoryPath(fileId));
+};
+
+export const cleanupFileCaches = async () => {
+  // Files were cached as single files directly under `/cache` before
+  await deleteFilesInDirectory("/cache");
+
+  // Uploads might be in progress in other tabs, so only stale ones are deleted
+  for (const name of await listDirectoryNames(UPLOAD_CACHE_DIRECTORY)) {
+    const createdAt = parseInt(name, 10);
+    if (!(Date.now() - createdAt < STALE_UPLOAD_CACHE_AGE)) {
+      await deleteDirectory(`${UPLOAD_CACHE_DIRECTORY}/${name}`);
+    }
+  }
+};

src/lib/client/cache/index.ts

@@ -0,0 +1,2 @@
+export * from "./file-cache.ts";
+export * from "./thumbnail-cache.svelte.ts";

src/lib/client/cache/thumbnail-cache.svelte.ts

@@ -0,0 +1,86 @@
+/* eslint-disable svelte/prefer-svelte-reactivity -- Lookup tables of reactive entries */
+import { LRUCache } from "lru-cache";
+import { deleteDirectory, deleteFile, readFile, writeFile } from "#lib/client/storage/opfs.ts";
+import { decryptChunk, encodeToBase64 } from "#lib/shared/crypto/index.ts";
+
+export interface Thumbnail {
+  url?: string;
+}
+
+const getThumbnailUrl = (thumbnailBuffer: ArrayBuffer) => {
+  return `data:image/webp;base64,${encodeToBase64(thumbnailBuffer)}`;
+};
+
+// Thumbnails are reactive so that they can be updated in place
+const loadedThumbnails = new LRUCache<number, Thumbnail>({ max: 100 });
+const loadingThumbnails = new Map<number, Thumbnail>();
+
+const fetchFromOpfs = async (fileId: number) => {
+  const thumbnailBuffer = await readFile(`/thumbnail/file/${fileId}`);
+  if (thumbnailBuffer) {
+    return getThumbnailUrl(thumbnailBuffer);
+  }
+};
+
+const fetchFromServer = async (fileId: number, dataKey: CryptoKey) => {
+  const res = await fetch(`/api/file/${fileId}/thumbnail/download`);
+  if (!res.ok) return null;
+
+  const thumbnailBuffer = await decryptChunk(await res.arrayBuffer(), dataKey);
+
+  void writeFile(`/thumbnail/file/${fileId}`, thumbnailBuffer);
+  return getThumbnailUrl(thumbnailBuffer);
+};
+
+export const getFileThumbnail = (file: {
+  id: number;
+  contentType: string;
+  dataKey?: { key: CryptoKey };
+}) => {
+  if (!(file.contentType.startsWith("image/") || file.contentType.startsWith("video/"))) {
+    return undefined;
+  }
+
+  const thumbnail = loadedThumbnails.get(file.id) ?? loadingThumbnails.get(file.id);
+  if (thumbnail) return thumbnail;
+
+  const loadingThumbnail: Thumbnail = $state({});
+  loadingThumbnails.set(file.id, loadingThumbnail);
+
+  fetchFromOpfs(file.id)
+    .then((url) => url ?? (file.dataKey && fetchFromServer(file.id, file.dataKey.key)))
+    .then((url) => {
+      if (url) {
+        loadingThumbnail.url = url;
+        loadedThumbnails.set(file.id, loadingThumbnail);
+      }
+    })
+    .catch(console.error)
+    .finally(() => {
+      loadingThumbnails.delete(file.id);
+    });
+  return loadingThumbnail;
+};
+
+export const storeFileThumbnailCache = async (fileId: number, thumbnailBuffer: ArrayBuffer) => {
+  await writeFile(`/thumbnail/file/${fileId}`, thumbnailBuffer);
+
+  const url = getThumbnailUrl(thumbnailBuffer);
+  const thumbnail = loadedThumbnails.get(fileId) ?? loadingThumbnails.get(fileId);
+  if (thumbnail) {
+    thumbnail.url = url;
+  } else {
+    const newThumbnail: Thumbnail = $state({ url });
+    loadedThumbnails.set(fileId, newThumbnail);
+  }
+};
+
+export const deleteFileThumbnailCache = async (fileId: number) => {
+  loadedThumbnails.delete(fileId);
+  await deleteFile(`/thumbnail/file/${fileId}`);
+};
+
+export const deleteAllFileThumbnailCaches = async () => {
+  loadedThumbnails.clear();
+  await deleteDirectory(`/thumbnail/file`);
+};

src/lib/client/crypto/hmac.ts

@@ -1,23 +1,7 @@
-import HmacWorker from "$workers/hmac?worker";
+import type { ComputeMessage, ResultMessage } from "#workers/hmac.ts";
-import type { ComputeMessage, ResultMessage } from "$workers/hmac";
+import HmacWorker from "#workers/hmac.ts?worker";
-
-export const digestMessage = async (message: BufferSource) => {
-  return await crypto.subtle.digest("SHA-256", message);
-};
-
-export const generateHmacSecret = async () => {
-  return {
-    hmacSecret: await crypto.subtle.generateKey(
-      {
-        name: "HMAC",
-        hash: "SHA-256",
-      } satisfies HmacKeyGenParams,
-      true,
-      ["sign", "verify"],
-    ),
-  };
-};
 
+// Computes HMAC of large blobs incrementally in a worker, which WebCrypto doesn't support
 export const signMessageHmac = async (message: Blob, hmacSecret: CryptoKey) => {
   const stream = message.stream();
   const hmacSecretRaw = new Uint8Array(await crypto.subtle.exportKey("raw", hmacSecret));
@@ -25,7 +9,11 @@ export const signMessageHmac = async (message: Blob, hmacSecret: CryptoKey) => {
 
   return new Promise<Uint8Array>((resolve, reject) => {
     worker.onmessage = ({ data }: MessageEvent<ResultMessage>) => {
-      resolve(data.result);
+      if ("result" in data) {
+        resolve(data.result);
+      } else {
+        reject(data.error);
+      }
       worker.terminate();
     };
 

src/lib/client/keys/generation.ts

@@ -1,31 +1,28 @@
 import {
-  generateEncryptionKeyPair,
+  concatenateBuffers,
-  generateSigningKeyPair,
+  digestMessage,
+  exportRSAKey,
   exportRSAKeyToBase64,
+  generateEncryptionKeyPair,
+  generateHmacSecret,
+  generateMasterKey,
+  generateSigningKeyPair,
   importEncryptionKeyPairFromBase64,
   importSigningKeyPairFromBase64,
-  makeRSAKeyNonextractable,
-  wrapMasterKey,
-  generateMasterKey,
   makeAESKeyNonextractable,
+  makeRSAKeyNonextractable,
   wrapHmacSecret,
-  generateHmacSecret,
+  wrapMasterKey,
-} from "$lib/modules/crypto";
+} from "#lib/shared/crypto/index.ts";
-import { deserializeClientKeys } from "$lib/modules/key";
+import { keyring } from "./keyring.svelte.ts";
-import { clientKeyStore } from "$lib/stores";
+import { deserializeClientKeys } from "./serialization.ts";
-
-export { requestLogout } from "$lib/services/auth";
-export { requestDeletedFilesCleanup } from "$lib/services/file";
-export {
-  requestClientRegistrationAndSessionUpgrade,
-  requestInitialMasterKeyAndHmacSecretRegistration,
-} from "$lib/services/key";
 
+// Generates new client keys and keeps them in the keyring without persisting
 export const generateClientKeys = async () => {
   const { encryptKey, decryptKey } = await generateEncryptionKeyPair();
   const { signKey, verifyKey } = await generateSigningKeyPair();
 
-  clientKeyStore.set({
+  keyring.setClientKeys({
     encryptKey,
     decryptKey: await makeRSAKeyNonextractable(decryptKey),
     signKey: await makeRSAKeyNonextractable(signKey),
@@ -41,6 +38,28 @@ export const generateClientKeys = async () => {
   };
 };
 
+export const importClientKeys = async (clientKeysSerialized: string) => {
+  const clientKeys = deserializeClientKeys(clientKeysSerialized);
+  if (!clientKeys) return false;
+
+  const { encryptKey, decryptKey } = await importEncryptionKeyPairFromBase64(
+    clientKeys.encryptKeyBase64,
+    clientKeys.decryptKeyBase64,
+  );
+  const { signKey, verifyKey } = await importSigningKeyPairFromBase64(
+    clientKeys.signKeyBase64,
+    clientKeys.verifyKeyBase64,
+  );
+
+  keyring.setClientKeys({
+    encryptKey,
+    decryptKey: await makeRSAKeyNonextractable(decryptKey),
+    signKey: await makeRSAKeyNonextractable(signKey),
+    verifyKey,
+  });
+  return true;
+};
+
 export const generateInitialMasterKey = async (encryptKey: CryptoKey) => {
   const { masterKey } = await generateMasterKey();
   return {
@@ -56,24 +75,14 @@ export const generateInitialHmacSecret = async (masterKey: CryptoKey) => {
   };
 };
 
-export const importClientKeys = async (clientKeysSerialized: string) => {
+export const generatePublicKeyFingerprint = async (encryptKey: CryptoKey, verifyKey: CryptoKey) => {
-  const clientKeys = deserializeClientKeys(clientKeysSerialized);
+  const { key: encryptKeyBuffer } = await exportRSAKey(encryptKey);
-  if (!clientKeys) return false;
+  const { key: verifyKeyBuffer } = await exportRSAKey(verifyKey);
-
+  const digest = await digestMessage(concatenateBuffers(encryptKeyBuffer, verifyKeyBuffer));
-  const { encryptKey, decryptKey } = await importEncryptionKeyPairFromBase64(
+  return Array.from(new Uint8Array(digest))
-    clientKeys.encryptKeyBase64,
+    .map((byte) => byte.toString(16).padStart(2, "0"))
-    clientKeys.decryptKeyBase64,
+    .join("")
-  );
+    .toUpperCase()
-  const { signKey, verifyKey } = await importSigningKeyPairFromBase64(
+    .match(/.{1,4}/g)!
-    clientKeys.signKeyBase64,
+    .join(" ");
-    clientKeys.verifyKeyBase64,
-  );
-
-  clientKeyStore.set({
-    encryptKey,
-    decryptKey: await makeRSAKeyNonextractable(decryptKey),
-    signKey: await makeRSAKeyNonextractable(signKey),
-    verifyKey,
-  });
-  return true;
 };

src/lib/client/keys/index.ts

@@ -0,0 +1,5 @@
+export * from "./generation.ts";
+export * from "./keyring.svelte.ts";
+export * from "./serialization.ts";
+export * from "./sync.ts";
+export * from "./types.ts";

src/lib/client/keys/keyring.svelte.ts

@@ -0,0 +1,113 @@
+import {
+  getClientKey,
+  getHmacSecrets,
+  getMasterKeys,
+  storeClientKey,
+  storeHmacSecrets,
+  storeMasterKeys,
+} from "#lib/client/storage/indexed-db/index.ts";
+import type { ClientKeys, HmacSecret, MasterKey } from "./types.ts";
+
+const findLatestActive = <T extends { version: number; state: string }>(
+  entries: ReadonlyMap<number, T>,
+) => {
+  return entries
+    .values()
+    .filter(({ state }) => state === "active")
+    .reduce<T | undefined>(
+      (latest, entry) => ((latest?.version ?? 0) > entry.version ? latest : entry),
+      undefined,
+    );
+};
+
+// Holds the keys of this device and the user. Keys are persisted in IndexedDB.
+class Keyring {
+  clientKeys = $state.raw<ClientKeys | null>(null);
+  masterKeys = $state.raw<ReadonlyMap<number, MasterKey>>(new Map());
+  hmacSecrets = $state.raw<ReadonlyMap<number, HmacSecret>>(new Map());
+
+  async load() {
+    const [encryptKey, decryptKey, signKey, verifyKey, masterKeys, hmacSecrets] = await Promise.all(
+      [
+        getClientKey("encrypt"),
+        getClientKey("decrypt"),
+        getClientKey("sign"),
+        getClientKey("verify"),
+        getMasterKeys(),
+        getHmacSecrets(),
+      ],
+    );
+    if (encryptKey && decryptKey && signKey && verifyKey) {
+      this.clientKeys = { encryptKey, decryptKey, signKey, verifyKey };
+    }
+    this.masterKeys = new Map(masterKeys.map((masterKey) => [masterKey.version, masterKey]));
+    this.hmacSecrets = new Map(hmacSecrets.map((hmacSecret) => [hmacSecret.version, hmacSecret]));
+  }
+
+  // Client keys are kept in memory only until they are registered and persisted
+  setClientKeys(clientKeys: ClientKeys) {
+    this.clientKeys = clientKeys;
+  }
+
+  async persistClientKeys() {
+    const clientKeys = this.requireClientKeys();
+    await Promise.all([
+      storeClientKey(clientKeys.encryptKey, "encrypt"),
+      storeClientKey(clientKeys.decryptKey, "decrypt"),
+      storeClientKey(clientKeys.signKey, "sign"),
+      storeClientKey(clientKeys.verifyKey, "verify"),
+    ]);
+  }
+
+  async setMasterKeys(masterKeys: MasterKey[]) {
+    await storeMasterKeys(masterKeys);
+    this.masterKeys = new Map(masterKeys.map((masterKey) => [masterKey.version, masterKey]));
+  }
+
+  async setHmacSecrets(hmacSecrets: HmacSecret[]) {
+    await storeHmacSecrets(hmacSecrets);
+    this.hmacSecrets = new Map(hmacSecrets.map((hmacSecret) => [hmacSecret.version, hmacSecret]));
+  }
+
+  get hasMasterKeys() {
+    return this.masterKeys.size > 0;
+  }
+
+  get hasHmacSecrets() {
+    return this.hmacSecrets.size > 0;
+  }
+
+  requireClientKeys() {
+    if (!this.clientKeys) {
+      throw new Error("Client keys not found");
+    }
+    return this.clientKeys;
+  }
+
+  getMasterKey(version: number) {
+    const masterKey = this.masterKeys.get(version);
+    if (!masterKey) {
+      throw new Error(`Master key (version ${version}) not found`);
+    }
+    return masterKey;
+  }
+
+  // The master key used to encrypt new data
+  get activeMasterKey() {
+    const masterKey = findLatestActive(this.masterKeys);
+    if (!masterKey) {
+      throw new Error("Active master key not found");
+    }
+    return masterKey;
+  }
+
+  get activeHmacSecret() {
+    const hmacSecret = findLatestActive(this.hmacSecrets);
+    if (!hmacSecret) {
+      throw new Error("Active HMAC secret not found");
+    }
+    return hmacSecret;
+  }
+}
+
+export const keyring = new Keyring();

src/lib/client/keys/serialization.ts

@@ -1,6 +1,4 @@
 import { z } from "zod";
-import { storeClientKey } from "$lib/indexedDB";
-import type { ClientKeys } from "$lib/stores";
 
 const SerializedClientKeysSchema = z.intersection(
   z.object({
@@ -54,12 +52,3 @@ export const deserializeClientKeys = (serialized: string) => {
   }
   return undefined;
 };
-
-export const storeClientKeys = async (clientKeys: ClientKeys) => {
-  await Promise.all([
-    storeClientKey(clientKeys.encryptKey, "encrypt"),
-    storeClientKey(clientKeys.decryptKey, "decrypt"),
-    storeClientKey(clientKeys.signKey, "sign"),
-    storeClientKey(clientKeys.verifyKey, "verify"),
-  ]);
-};

src/lib/client/keys/sync.ts

@@ -0,0 +1,182 @@
+import {
+  decryptChallenge,
+  encodeToBase64,
+  exportRSAKeyToBase64,
+  signMasterKeyWrapped,
+  signMessageRSA,
+  unwrapHmacSecret,
+  unwrapMasterKey,
+  verifyMasterKeyWrapped,
+} from "#lib/shared/crypto/index.ts";
+import { isTRPCClientError, trpc } from "#trpc/client.ts";
+import { keyring } from "./keyring.svelte.ts";
+import type { ClientKeys } from "./types.ts";
+
+// Synchronizes keys with the server
+
+const exportPublicKeys = async ({ encryptKey, verifyKey }: ClientKeys) => ({
+  encPubKey: await exportRSAKeyToBase64(encryptKey),
+  sigPubKey: await exportRSAKeyToBase64(verifyKey),
+});
+
+const answerChallenge = async (challenge: string, { decryptKey, signKey }: ClientKeys) => {
+  const answer = await decryptChallenge(challenge, decryptKey);
+  return encodeToBase64(await signMessageRSA(answer, signKey));
+};
+
+export const requestSessionUpgrade = async (force = false) => {
+  const clientKeys = keyring.requireClientKeys();
+
+  let id, challenge;
+  try {
+    ({ id, challenge } = await trpc.auth.upgrade.mutate(await exportPublicKeys(clientKeys)));
+  } catch (e) {
+    if (isTRPCClientError(e) && e.data?.code === "FORBIDDEN") {
+      return [false, "Unregistered client"] as const;
+    }
+    return [false] as const;
+  }
+
+  try {
+    await trpc.auth.verifyUpgrade.mutate({
+      id,
+      answerSig: await answerChallenge(challenge, clientKeys),
+      force,
+    });
+  } catch (e) {
+    if (isTRPCClientError(e) && e.data?.code === "CONFLICT") {
+      return [false, "Already logged in"] as const;
+    }
+    return [false] as const;
+  }
+
+  return [true] as const;
+};
+
+export const requestClientRegistration = async () => {
+  const clientKeys = keyring.requireClientKeys();
+
+  try {
+    const { id, challenge } = await trpc.client.register.mutate(await exportPublicKeys(clientKeys));
+    await trpc.client.verify.mutate({
+      id,
+      answerSig: await answerChallenge(challenge, clientKeys),
+    });
+    return true;
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+};
+
+export const requestClientRegistrationAndSessionUpgrade = async (force: boolean) => {
+  const [res, error] = await requestSessionUpgrade(force);
+  if (error === undefined) return [res] as const;
+
+  if (error === "Unregistered client" && !(await requestClientRegistration())) {
+    return [false] as const;
+  } else if (error === "Already logged in") {
+    return [false, force ? undefined : error] as const;
+  }
+
+  return [(await requestSessionUpgrade())[0]] as const;
+};
+
+export const registerInitialMasterKeyAndHmacSecret = async (
+  masterKeyWrapped: string,
+  hmacSecretWrapped: string,
+) => {
+  const { signKey } = keyring.requireClientKeys();
+
+  try {
+    await trpc.mek.registerInitial.mutate({
+      mek: masterKeyWrapped,
+      mekSig: await signMasterKeyWrapped(masterKeyWrapped, 1, signKey),
+    });
+  } catch (e) {
+    if (isTRPCClientError(e) && (e.data?.code === "FORBIDDEN" || e.data?.code === "CONFLICT")) {
+      return true; // Already registered by another client
+    }
+    console.error(e);
+    return false;
+  }
+
+  try {
+    await trpc.hsk.registerInitial.mutate({
+      mekVersion: 1,
+      hsk: hmacSecretWrapped,
+    });
+    return true;
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+};
+
+export const downloadHmacSecrets = async () => {
+  let hmacSecretsWrapped;
+  try {
+    hmacSecretsWrapped = await trpc.hsk.list.query();
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+
+  const hmacSecrets = await Promise.all(
+    hmacSecretsWrapped.map(async ({ version, state, mekVersion, hsk: hmacSecretWrapped }) => {
+      const { hmacSecret } = await unwrapHmacSecret(
+        hmacSecretWrapped,
+        keyring.getMasterKey(mekVersion).key,
+      );
+      return { version, state, secret: hmacSecret };
+    }),
+  );
+
+  await keyring.setHmacSecrets(hmacSecrets);
+  return true;
+};
+
+// Downloads the master keys (and HMAC secrets) once this client has been approved
+export const downloadMasterKeys = async () => {
+  const { decryptKey, verifyKey } = keyring.requireClientKeys();
+
+  let masterKeysWrapped;
+  try {
+    masterKeysWrapped = await trpc.mek.list.query();
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+
+  const masterKeys = await Promise.all(
+    masterKeysWrapped.map(
+      async ({ version, state, mek: masterKeyWrapped, mekSig: masterKeyWrappedSig }) => {
+        const { masterKey } = await unwrapMasterKey(masterKeyWrapped, decryptKey);
+        return {
+          version,
+          state,
+          key: masterKey,
+          isValid: await verifyMasterKeyWrapped(
+            masterKeyWrapped,
+            version,
+            masterKeyWrappedSig,
+            verifyKey,
+          ),
+        };
+      },
+    ),
+  );
+  if (masterKeys.length === 0 || !masterKeys.every(({ isValid }) => isValid)) return false;
+
+  await keyring.setMasterKeys(
+    masterKeys.map(({ version, state, key }) => ({ version, state, key })),
+  );
+  await downloadHmacSecrets();
+  return true;
+};
+
+export const ensureHmacSecrets = async () => {
+  if (!keyring.hasHmacSecrets && !(await downloadHmacSecrets())) {
+    throw new Error("Failed to download HMAC secrets");
+  }
+};

src/lib/client/keys/types.ts

@@ -0,0 +1,18 @@
+export interface ClientKeys {
+  encryptKey: CryptoKey;
+  decryptKey: CryptoKey;
+  signKey: CryptoKey;
+  verifyKey: CryptoKey;
+}
+
+export interface MasterKey {
+  version: number;
+  state: "active" | "retired";
+  key: CryptoKey;
+}
+
+export interface HmacSecret {
+  version: number;
+  state: "active";
+  secret: CryptoKey;
+}

src/lib/client/media/exif.ts

@@ -0,0 +1,52 @@
+import ExifReader from "exifreader";
+
+const isInteger = (value: number | undefined): value is number => Number.isInteger(value);
+
+export const extractExifDateTime = (fileBuffer: ArrayBuffer) => {
+  const exif = ExifReader.load(fileBuffer);
+  const dateTimeOriginal = exif["DateTimeOriginal"]?.description;
+  const offsetTimeOriginal = exif["OffsetTimeOriginal"]?.description;
+  if (!dateTimeOriginal) return undefined;
+
+  const [date, time] = dateTimeOriginal.split(" ");
+  if (!date || !time) return undefined;
+
+  const [year, month, day] = date.split(":").map(Number);
+  const [hour, minute, second] = time.split(":").map(Number);
+  // Hours, minutes, and seconds may be 0, so they are checked differently
+  if (!year || !month || !day || !isInteger(hour) || !isInteger(minute) || !isInteger(second)) {
+    return undefined;
+  }
+
+  if (!offsetTimeOriginal) {
+    // No timezone information.. Assume local timezone
+    return new Date(year, month - 1, day, hour, minute, second);
+  }
+
+  const offsetSign = offsetTimeOriginal[0] === "+" ? 1 : -1;
+  const [offsetHour, offsetMinute] = offsetTimeOriginal.slice(1).split(":").map(Number);
+
+  const utcDate = Date.UTC(year, month - 1, day, hour, minute, second);
+  const offsetMs = offsetSign * ((offsetHour ?? 0) * 60 + (offsetMinute ?? 0)) * 60 * 1000;
+  return new Date(utcDate - offsetMs);
+};
+
+const EXIF_SEARCH_SIZE = 1024 * 1024; // 1 MiB
+const MAX_FULL_READ_SIZE = 64 * 1024 * 1024; // 64 MiB
+
+const tryExtractExifDateTime = (buffer: ArrayBuffer) => {
+  try {
+    return extractExifDateTime(buffer);
+  } catch {
+    return undefined;
+  }
+};
+
+// EXIF is usually at the beginning of the file, so the whole file is read only if not found
+export const readExifDateTime = async (file: Blob) => {
+  const dateTime = tryExtractExifDateTime(await file.slice(0, EXIF_SEARCH_SIZE).arrayBuffer());
+  if (dateTime || file.size <= EXIF_SEARCH_SIZE || file.size > MAX_FULL_READ_SIZE) {
+    return dateTime;
+  }
+  return tryExtractExifDateTime(await file.arrayBuffer());
+};

src/lib/client/media/heic.ts

@@ -0,0 +1,5 @@
+// Chromium can't decode HEIC images, so they are converted to be displayed
+export const convertHeic = async (blob: Blob, toType: "image/png" | "image/jpeg") => {
+  const { default: heic2any } = await import("heic2any");
+  return (await heic2any({ blob, toType })) as Blob;
+};

src/lib/client/media/thumbnail.ts

@@ -1,4 +1,4 @@
-import { encodeToBase64 } from "$lib/modules/crypto";
+import { convertHeic } from "./heic.ts";
 
 const scaleSize = (width: number, height: number, targetSize: number) => {
   if (width <= targetSize || height <= targetSize) {
@@ -62,61 +62,88 @@ export const captureVideoThumbnail = (video: HTMLVideoElement) => {
   });
 };
 
+const VIDEO_THUMBNAIL_TIMEOUT_MS = 30_000;
+
 const generateVideoThumbnail = (videoUrl: string, time = 0) => {
   return new Promise<Blob>((resolve, reject) => {
     const video = document.createElement("video");
+    let isCaptured = false;
+
+    const cleanup = () => {
+      clearTimeout(timeout);
+      video.onloadedmetadata = video.onloadeddata = video.onseeked = video.onerror = null;
+      video.removeAttribute("src");
+      video.load(); // Stops loading the video
+    };
+    const fail = (reason: unknown) => {
+      cleanup();
+      reject(reason);
+    };
+    const captureFrame = () => {
+      if (isCaptured || video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) return;
+      isCaptured = true;
+      captureVideoThumbnail(video).then(resolve, reject).finally(cleanup);
+    };
+
+    // Streamed videos may stall without any error
+    const timeout = setTimeout(
+      () => fail(new Error("Timed out while loading the video")),
+      VIDEO_THUMBNAIL_TIMEOUT_MS,
+    );
+
     video.onloadedmetadata = () => {
       if (video.videoWidth === 0 || video.videoHeight === 0) {
-        return reject();
+        return fail(new Error("Invalid video size"));
       }
 
-      const callbackId = video.requestVideoFrameCallback(() => {
+      // Frame callbacks aren't guaranteed for videos not in the document, so also wait for seeking
-        captureVideoThumbnail(video).then(resolve).catch(reject);
+      video.requestVideoFrameCallback(captureFrame);
-        video.cancelVideoFrameCallback(callbackId);
+      video.onseeked = captureFrame;
-      });
+      if (time === 0) {
+        video.onloadeddata = captureFrame;
+      }
       video.currentTime = Math.min(time, video.duration);
     };
-    video.onerror = reject;
+    video.onerror = () => fail(video.error);
 
     video.muted = true;
     video.playsInline = true;
+    video.preload = "auto";
     video.src = videoUrl;
   });
 };
 
-export const generateThumbnail = async (blob: Blob) => {
+// Generates a thumbnail of the image or video at the URL. Returns `null` if not supported.
-  let url;
+export const generateThumbnailFromUrl = async (url: string, contentType: string) => {
   try {
-    if (blob.type.startsWith("image/")) {
+    if (contentType.startsWith("image/")) {
-      url = URL.createObjectURL(blob);
       try {
         return await generateImageThumbnail(url);
       } catch {
-        URL.revokeObjectURL(url);
+        if (contentType !== "image/heic") return null;
-        url = undefined;
 
-        if (blob.type === "image/heic") {
+        const blob = await (await fetch(url)).blob();
-          const { default: heic2any } = await import("heic2any");
+        const png = URL.createObjectURL(await convertHeic(blob, "image/png"));
-          url = URL.createObjectURL((await heic2any({ blob, toType: "image/png" })) as Blob);
+        try {
-          return await generateImageThumbnail(url);
+          return await generateImageThumbnail(png);
-        } else {
+        } finally {
-          return null;
+          URL.revokeObjectURL(png);
         }
       }
-    } else if (blob.type.startsWith("video/")) {
+    } else if (contentType.startsWith("video/")) {
-      url = URL.createObjectURL(blob);
       return await generateVideoThumbnail(url);
     }
     return null;
   } catch {
     return null;
-  } finally {
-    if (url) {
-      URL.revokeObjectURL(url);
-    }
   }
 };
 
-export const getThumbnailUrl = (thumbnailBuffer: ArrayBuffer) => {
+export const generateThumbnail = async (blob: Blob) => {
-  return `data:image/webp;base64,${encodeToBase64(thumbnailBuffer)}`;
+  const url = URL.createObjectURL(blob);
+  try {
+    return await generateThumbnailFromUrl(url, blob.type);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
 };

src/lib/client/service-worker.ts

@@ -0,0 +1,80 @@
+import { LRUCache } from "lru-cache";
+import { handleDownloadProgress } from "#lib/client/transfer/download.svelte.ts";
+import {
+  DECRYPTED_FILE_URL_PREFIX,
+  MAX_PREPARED_FILES,
+  type FileMetadata,
+  type ServiceWorkerMessage,
+  type ServiceWorkerResponse,
+} from "#lib/shared/service-worker.ts";
+
+const PREPARE_TIMEOUT_MS = 5000;
+
+// The service worker may be terminated at any time, losing its in-memory metadata.
+// Keep a copy here so that it can be re-requested on demand.
+const preparedFiles = new LRUCache<number, FileMetadata>({ max: MAX_PREPARED_FILES });
+let isListening = false;
+
+export const listenForServiceWorkerMessages = () => {
+  if (isListening) return;
+  isListening = true;
+
+  navigator.serviceWorker.addEventListener(
+    "message",
+    (event: MessageEvent<ServiceWorkerResponse>) => {
+      switch (event.data.type) {
+        case "decryption-metadata-request":
+          event.ports[0]?.postMessage(preparedFiles.get(event.data.fileId) ?? null);
+          break;
+        case "download-progress":
+          handleDownloadProgress(event.data);
+          break;
+      }
+    },
+  );
+};
+
+const getServiceWorker = async () => {
+  const registration = await navigator.serviceWorker.ready;
+  const sw = registration.active;
+  if (!sw) {
+    throw new Error("Service worker not activated");
+  }
+  return sw;
+};
+
+export const prepareFileDecryption = async (id: number, metadata: FileMetadata) => {
+  preparedFiles.set(id, metadata);
+  listenForServiceWorkerMessages();
+
+  const sw = await getServiceWorker();
+  return new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(
+      () => reject(new Error("Service worker timeout")),
+      PREPARE_TIMEOUT_MS,
+    );
+    const handler = (event: MessageEvent<ServiceWorkerResponse>) => {
+      if (event.data.type === "decryption-ready" && event.data.fileId === id) {
+        clearTimeout(timeout);
+        navigator.serviceWorker.removeEventListener("message", handler);
+        resolve();
+      }
+    };
+    navigator.serviceWorker.addEventListener("message", handler);
+
+    sw.postMessage({
+      type: "decryption-prepare",
+      fileId: id,
+      ...metadata,
+    } satisfies ServiceWorkerMessage);
+  });
+};
+
+export const getDecryptedFileUrl = (id: number) => `${DECRYPTED_FILE_URL_PREFIX}${id}`;
+
+// Lets the service worker download, decrypt, and save the file
+export const saveDecryptedFile = (id: number, filename: string) => {
+  const link = document.createElement("a");
+  link.href = `${getDecryptedFileUrl(id)}?download=${encodeURIComponent(filename)}`;
+  link.click();
+};

src/lib/client/storage/indexed-db/cache-index.ts

@@ -0,0 +1,46 @@
+import { Dexie, type EntityTable } from "dexie";
+
+export interface FileCacheIndex {
+  fileId: number;
+  cachedAt: Date;
+  lastRetrievedAt: Date;
+  // Files are cached in chunks, possibly partially (e.g. videos which were partially played)
+  size: number;
+  totalSize: number;
+  chunkCount: number;
+  isComplete: boolean;
+}
+
+const cacheIndex = new Dexie("cacheIndex") as Dexie & {
+  fileCache: EntityTable<FileCacheIndex, "fileId">;
+};
+
+// Files were cached as single files before version 2
+cacheIndex
+  .version(2)
+  .stores({
+    fileCache: "fileId",
+  })
+  .upgrade(async (trx) => {
+    await trx.table("fileCache").clear();
+  });
+
+export const getFileCacheIndex = async () => {
+  return await cacheIndex.fileCache.toArray();
+};
+
+export const getFileCacheIndexOf = async (fileId: number) => {
+  return await cacheIndex.fileCache.get(fileId);
+};
+
+export const storeFileCacheIndex = async (fileCacheIndex: FileCacheIndex) => {
+  await cacheIndex.fileCache.put(fileCacheIndex);
+};
+
+export const updateFileCacheRetrievedAt = async (fileId: number, lastRetrievedAt: Date) => {
+  await cacheIndex.fileCache.update(fileId, { lastRetrievedAt });
+};
+
+export const deleteFileCacheIndex = async (fileId: number) => {
+  await cacheIndex.fileCache.delete(fileId);
+};

src/lib/client/storage/indexed-db/index.ts

@@ -0,0 +1,3 @@
+export * from "./cache-index.ts";
+export * from "./filesystem.ts";
+export * from "./key-store.ts";

src/lib/client/storage/opfs.ts

@@ -48,6 +48,12 @@ export const writeFile = async (path: string, data: ArrayBuffer) => {
   }
 };
 
+// Changes are applied atomically when the stream is closed, and discarded if it is aborted
+export const createWritable = async (path: string) => {
+  const { fileHandle } = await getFileHandle(path);
+  return await fileHandle!.createWritable();
+};
+
 export const deleteFile = async (path: string) => {
   const { parentHandle, filename } = await getFileHandle(path, false);
   if (!parentHandle) return;
@@ -88,3 +94,51 @@ export const deleteDirectory = async (path: string) => {
 
   await parentHandle.removeEntry(directoryHandle.name, { recursive: true });
 };
+
+const listEntryNames = async (path: string, kind: FileSystemHandleKind) => {
+  const { directoryHandle } = await getDirectoryHandle(path);
+  if (!directoryHandle) return [];
+
+  const names: string[] = [];
+  for await (const handle of directoryHandle.values()) {
+    if (handle.kind === kind) {
+      names.push(handle.name);
+    }
+  }
+  return names;
+};
+
+export const listFileNames = (path: string) => listEntryNames(path, "file");
+
+export const listDirectoryNames = (path: string) => listEntryNames(path, "directory");
+
+// Deletes the files (not directories) directly under the directory
+export const deleteFilesInDirectory = async (path: string) => {
+  const { directoryHandle } = await getDirectoryHandle(path);
+  if (!directoryHandle) return;
+
+  for (const name of await listFileNames(path)) {
+    await directoryHandle.removeEntry(name);
+  }
+};
+
+// Renames the file atomically
+export const moveFile = async (path: string, newPath: string) => {
+  const { fileHandle } = await getFileHandle(path, false);
+  if (!fileHandle) {
+    throw new Error("File not found");
+  }
+
+  let directoryHandle = await navigator.storage.getDirectory();
+  const parts = newPath.split("/").filter((part) => part);
+  for (const part of parts.slice(0, -1)) {
+    directoryHandle = await directoryHandle.getDirectoryHandle(part, { create: true });
+  }
+
+  // Supported by Chromium for the origin private file system
+  await (
+    fileHandle as FileSystemFileHandle & {
+      move(destination: FileSystemDirectoryHandle, name: string): Promise<void>;
+    }
+  ).move(directoryHandle, parts.at(-1)!);
+};

src/lib/client/transfer/chunked-upload.ts

@@ -0,0 +1,130 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+import axios from "axios";
+import { encodeToBase64, encryptChunk } from "#lib/shared/crypto/index.ts";
+import { CHUNK_SIZE, getChunkCount, getEncryptedSize } from "#lib/shared/format/index.ts";
+import { BoundedQueue } from "#lib/utils/concurrency/index.ts";
+import { createSpeedMeter } from "#lib/utils/speed-meter.ts";
+
+interface UploadStats {
+  progress: number;
+  rate: number;
+}
+
+interface EncryptedChunk {
+  index: number;
+  data: ArrayBuffer;
+}
+
+const uploadEncryptedChunk = async (
+  uploadId: string,
+  chunkIndex: number,
+  encrypted: ArrayBuffer,
+  onChunkProgress: (chunkIndex: number, loaded: number) => void,
+) => {
+  await axios.post(`/api/upload/${uploadId}/chunks/${chunkIndex + 1}`, encrypted, {
+    headers: { "Content-Type": "application/octet-stream" },
+    onUploadProgress(e) {
+      onChunkProgress(chunkIndex, e.loaded ?? 0);
+    },
+  });
+
+  onChunkProgress(chunkIndex, encrypted.byteLength);
+};
+
+export const uploadBlob = async (
+  uploadId: string,
+  blob: Blob,
+  dataKey: CryptoKey,
+  options?: {
+    concurrency?: number;
+    onProgress?: (s: UploadStats) => void;
+    // Receives each chunk of the plaintext before it is encrypted
+    onPlaintextChunk?: (chunkIndex: number, data: ArrayBuffer) => Promise<void>;
+  },
+) => {
+  const onProgress = options?.onProgress;
+  const networkConcurrency = options?.concurrency ?? 4;
+  const maxQueueSize = 8;
+
+  const totalChunks = getChunkCount(blob.size);
+  const totalBytes = getEncryptedSize(blob.size);
+
+  const uploadedByChunk = new Array<number>(totalChunks).fill(0);
+  const speedMeter = createSpeedMeter(3000, 200);
+  const hash = sha256.create();
+
+  const emit = () => {
+    if (!onProgress) return;
+
+    const uploadedBytes = uploadedByChunk.reduce((a, b) => a + b, 0);
+    const rate = speedMeter(uploadedBytes);
+    const progress = Math.min(1, uploadedBytes / totalBytes);
+
+    onProgress({ progress, rate });
+  };
+
+  const onChunkProgress = (idx: number, loaded: number) => {
+    uploadedByChunk[idx] = loaded;
+    emit();
+  };
+
+  const queue = new BoundedQueue<EncryptedChunk>(maxQueueSize);
+
+  // Producer: encrypt chunks and push to queue
+  const encryptionProducer = async () => {
+    try {
+      for (let i = 0; i < totalChunks; i++) {
+        const chunk = await blob.slice(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE).arrayBuffer();
+        await options?.onPlaintextChunk?.(i, chunk);
+        const data = await encryptChunk(chunk, dataKey);
+        hash.update(new Uint8Array(data));
+        await queue.push({ index: i, data });
+      }
+    } finally {
+      queue.close();
+    }
+  };
+
+  // Consumer: upload chunks from queue with concurrency limit
+  const uploadConsumer = async () => {
+    const activeTasks = new Set<Promise<void>>();
+    let failure: { reason: unknown } | undefined;
+
+    try {
+      while (!failure) {
+        const item = await queue.pop();
+        if (item === null) break;
+
+        const task: Promise<void> = uploadEncryptedChunk(
+          uploadId,
+          item.index,
+          item.data,
+          onChunkProgress,
+        )
+          .catch((reason) => {
+            failure ??= { reason };
+          })
+          .finally(() => activeTasks.delete(task));
+        activeTasks.add(task);
+
+        if (activeTasks.size >= networkConcurrency) {
+          await Promise.race(activeTasks);
+        }
+      }
+
+      await Promise.all(activeTasks);
+      if (failure) throw failure.reason;
+    } finally {
+      queue.close(); // Stops the producer if the upload failed
+    }
+  };
+
+  // Run producer and consumer concurrently
+  const [encryption, upload] = await Promise.allSettled([encryptionProducer(), uploadConsumer()]);
+  // The upload error takes precedence, as the producer fails due to the closed queue then
+  if (upload.status === "rejected") throw upload.reason;
+  if (encryption.status === "rejected") throw encryption.reason;
+
+  onProgress?.({ progress: 1, rate: speedMeter() });
+  return { encContentHash: encodeToBase64(hash.digest()) };
+};

src/lib/client/transfer/download.svelte.ts

@@ -0,0 +1,55 @@
+import type { DownloadProgressMessage } from "#lib/shared/service-worker.ts";
+import { createSpeedMeter } from "#lib/utils/speed-meter.ts";
+
+// Files are downloaded and decrypted by the service worker, which reports the progress
+
+export interface FileDownloadState {
+  id: number;
+  status: "downloading" | "completed" | "error";
+  progress?: number;
+  rate?: number;
+}
+
+let downloadingFiles: FileDownloadState[] = $state([]);
+const speedMeters = new WeakMap<FileDownloadState, ReturnType<typeof createSpeedMeter>>();
+
+export const isFileDownloading = (status: FileDownloadState["status"]) => {
+  return status === "downloading";
+};
+
+export const getFileDownloadState = (fileId: number) => {
+  return downloadingFiles.find((file) => file.id === fileId && isFileDownloading(file.status));
+};
+
+export const getDownloadingFiles = () => {
+  return downloadingFiles.filter((file) => isFileDownloading(file.status));
+};
+
+export const clearDownloadedFiles = () => {
+  downloadingFiles = downloadingFiles.filter((file) => isFileDownloading(file.status));
+};
+
+export const handleDownloadProgress = ({
+  fileId,
+  status,
+  loaded,
+  total,
+}: DownloadProgressMessage) => {
+  let state = getFileDownloadState(fileId);
+  if (!state) {
+    if (status !== "downloading") return;
+
+    downloadingFiles.push({ id: fileId, status });
+    state = downloadingFiles.at(-1)!;
+    speedMeters.set(state, createSpeedMeter());
+  }
+
+  if (status === "canceled") {
+    downloadingFiles = downloadingFiles.filter((file) => file !== state);
+    return;
+  }
+
+  state.status = status;
+  state.progress = total > 0 ? loaded / total : 1;
+  state.rate = speedMeters.get(state)?.(loaded);
+};

src/lib/client/transfer/index.ts

@@ -0,0 +1,2 @@
+export * from "./download.svelte.ts";
+export * from "./upload.svelte.ts";

src/lib/client/transfer/upload.svelte.ts

@@ -1,53 +1,62 @@
-import ExifReader from "exifreader";
 import { limitFunction } from "p-limit";
-import { CHUNK_SIZE } from "$lib/constants";
+import { createUploadFileCache } from "#lib/client/cache/index.ts";
-import { encodeToBase64, generateDataKey, wrapDataKey, encryptString } from "$lib/modules/crypto";
+import { signMessageHmac } from "#lib/client/crypto/hmac.ts";
-import { signMessageHmac } from "$lib/modules/crypto";
+import {
-import { generateThumbnail } from "$lib/modules/thumbnail";
+  ensureHmacSecrets,
-import { uploadBlob } from "$lib/modules/upload";
+  keyring,
-import type { MasterKey, HmacSecret } from "$lib/stores";
+  type HmacSecret,
-import { Scheduler } from "$lib/utils";
+  type MasterKey,
-import { trpc } from "$trpc/client";
+} from "#lib/client/keys/index.ts";
+import { readExifDateTime } from "#lib/client/media/exif.ts";
+import { generateThumbnail } from "#lib/client/media/thumbnail.ts";
+import { uploadBlob } from "#lib/client/transfer/chunked-upload.ts";
+import {
+  encodeToBase64,
+  generateDataKey,
+  wrapDataKey,
+  encryptString,
+} from "#lib/shared/crypto/index.ts";
+import { getChunkCount } from "#lib/shared/format/index.ts";
+import { Scheduler } from "#lib/utils/index.ts";
+import { trpc } from "#trpc/client.ts";
+
+const LIVE_STATUSES = [
+  "queued",
+  "encryption-pending",
+  "encrypting",
+  "upload-pending",
+  "uploading",
+] as const;
+
+type LiveStatus = (typeof LIVE_STATUSES)[number];
 
 export interface FileUploadState {
   id: string;
   name: string;
   parentId: DirectoryId;
-  status:
+  status: LiveStatus | "uploaded" | "canceled" | "error";
-    | "queued"
-    | "encryption-pending"
-    | "encrypting"
-    | "upload-pending"
-    | "uploading"
-    | "uploaded"
-    | "canceled"
-    | "error";
   progress?: number;
   rate?: number;
   estimated?: number;
 }
 
-export type LiveFileUploadState = FileUploadState & {
+export type LiveFileUploadState = FileUploadState & { status: LiveStatus };
-  status: "queued" | "encryption-pending" | "encrypting" | "upload-pending" | "uploading";
-};
 
-const scheduler = new Scheduler<
+const scheduler = new Scheduler<{ fileId: number; thumbnailBuffer?: ArrayBuffer } | undefined>();
-  { fileId: number; fileBuffer?: ArrayBuffer; thumbnailBuffer?: ArrayBuffer } | undefined
->();
 let uploadingFiles: FileUploadState[] = $state([]);
 
-const isFileUploading = (status: FileUploadState["status"]) =>
+const isFileUploading = (file: FileUploadState): file is LiveFileUploadState => {
-  ["queued", "encryption-pending", "encrypting", "upload-pending", "uploading"].includes(status);
+  return (LIVE_STATUSES as readonly string[]).includes(file.status);
+};
 
 export const getUploadingFiles = (parentId?: DirectoryId) => {
-  return uploadingFiles.filter(
+  return uploadingFiles
-    (file) =>
+    .filter(isFileUploading)
-      (parentId === undefined || file.parentId === parentId) && isFileUploading(file.status),
+    .filter((file) => parentId === undefined || file.parentId === parentId);
-  );
 };
 
 export const clearUploadedFiles = () => {
-  uploadingFiles = uploadingFiles.filter((file) => isFileUploading(file.status));
+  uploadingFiles = uploadingFiles.filter(isFileUploading);
 };
 
 const requestDuplicateFileScan = limitFunction(
@@ -60,7 +69,7 @@ const requestDuplicateFileScan = limitFunction(
     state.status = "encryption-pending";
 
     const fileSigned = encodeToBase64(await signMessageHmac(file, hmacSecret.secret));
-    const files = await trpc().file.listByHash.query({
+    const files = await trpc.file.listByHash.query({
       hskVersion: hmacSecret.version,
       contentHmac: fileSigned,
     });
@@ -79,32 +88,6 @@ const getFileType = (file: File) => {
   throw new Error("Unknown file type");
 };
 
-const extractExifDateTime = (fileBuffer: ArrayBuffer) => {
-  const exif = ExifReader.load(fileBuffer);
-  const dateTimeOriginal = exif["DateTimeOriginal"]?.description;
-  const offsetTimeOriginal = exif["OffsetTimeOriginal"]?.description;
-  if (!dateTimeOriginal) return undefined;
-
-  const [date, time] = dateTimeOriginal.split(" ");
-  if (!date || !time) return undefined;
-
-  const [year, month, day] = date.split(":").map(Number);
-  const [hour, minute, second] = time.split(":").map(Number);
-  if (!year || !month || !day || !hour || !minute || !second) return undefined;
-
-  if (!offsetTimeOriginal) {
-    // No timezone information.. Assume local timezone
-    return new Date(year, month - 1, day, hour, minute, second);
-  }
-
-  const offsetSign = offsetTimeOriginal[0] === "+" ? 1 : -1;
-  const [offsetHour, offsetMinute] = offsetTimeOriginal.slice(1).split(":").map(Number);
-
-  const utcDate = Date.UTC(year, month - 1, day, hour, minute, second);
-  const offsetMs = offsetSign * ((offsetHour ?? 0) * 60 + (offsetMinute ?? 0)) * 60 * 1000;
-  return new Date(utcDate - offsetMs);
-};
-
 interface FileMetadata {
   parentId: "root" | number;
   name: string;
@@ -134,8 +117,8 @@ const requestFileMetadataEncryption = limitFunction(
         generateThumbnail(file).then((blob) => blob?.arrayBuffer()),
       ]);
 
-    const { uploadId } = await trpc().upload.startFileUpload.mutate({
+    const { uploadId } = await trpc.upload.startFileUpload.mutate({
-      chunks: Math.ceil(file.size / CHUNK_SIZE),
+      chunks: getChunkCount(file.size),
       parent: fileMetadata.parentId,
       mekVersion: masterKey.version,
       dek: dataKeyWrapped,
@@ -168,28 +151,41 @@ const requestFileUpload = limitFunction(
   ) => {
     state.status = "uploading";
 
-    await uploadBlob(uploadId, file, dataKey, {
+    // The file is cached while uploading, so that it doesn't have to be read again
-      onProgress(s) {
+    const cache = createUploadFileCache(file.size);
-        state.progress = s.progress;
-        state.rate = s.rate;
-      },
-    });
 
-    const { file: fileId } = await trpc().upload.completeFileUpload.mutate({
+    let fileId;
-      uploadId,
+    try {
-      contentHmac: fileSigned,
+      const { encContentHash } = await uploadBlob(uploadId, file, dataKey, {
-    });
+        onProgress(s) {
+          state.progress = s.progress;
+          state.rate = s.rate;
+        },
+        onPlaintextChunk: cache.writeChunk,
+      });
+
+      ({ file: fileId } = await trpc.upload.completeFileUpload.mutate({
+        uploadId,
+        contentHmac: fileSigned,
+        encContentHash,
+      }));
+    } catch (e) {
+      await cache.discard();
+      throw e;
+    }
+
+    await cache.commit(fileId).catch(console.error);
 
     if (thumbnailBuffer) {
       try {
-        const { uploadId } = await trpc().upload.startFileThumbnailUpload.mutate({
+        const { uploadId } = await trpc.upload.startFileThumbnailUpload.mutate({
           file: fileId,
           dekVersion: dataKeyVersion,
         });
 
         await uploadBlob(uploadId, new Blob([thumbnailBuffer]), dataKey);
 
-        await trpc().upload.completeFileThumbnailUpload.mutate({ uploadId });
+        await trpc.upload.completeFileThumbnailUpload.mutate({ uploadId });
       } catch (e) {
         console.error(e);
       }
@@ -204,8 +200,6 @@ const requestFileUpload = limitFunction(
 export const uploadFile = async (
   file: File,
   parentId: "root" | number,
-  masterKey: MasterKey,
-  hmacSecret: HmacSecret,
   onDuplicate: () => Promise<boolean>,
 ) => {
   uploadingFiles.push({
@@ -218,6 +212,10 @@ export const uploadFile = async (
 
   return await scheduler.schedule(file.size, async () => {
     try {
+      await ensureHmacSecrets();
+      const masterKey = keyring.activeMasterKey;
+      const hmacSecret = keyring.activeHmacSecret;
+
       const { fileSigned } = await requestDuplicateFileScan(state, file, hmacSecret, onDuplicate);
 
       if (!fileSigned) {
@@ -226,7 +224,6 @@ export const uploadFile = async (
         return;
       }
 
-      let fileBuffer;
       const fileType = getFileType(file);
       const fileMetadata: FileMetadata = {
         parentId,
@@ -235,8 +232,7 @@ export const uploadFile = async (
       };
 
       if (fileType.startsWith("image/")) {
-        fileBuffer = await file.arrayBuffer();
+        fileMetadata.createdAt = await readExifDateTime(file);
-        fileMetadata.createdAt = extractExifDateTime(fileBuffer);
       }
 
       const blob = new Blob([file], { type: fileType });
@@ -254,7 +250,7 @@ export const uploadFile = async (
         dataKeyVersion,
       );
 
-      return { fileId, fileBuffer, thumbnailBuffer };
+      return { fileId, thumbnailBuffer };
     } catch (e) {
       state.status = "error";
       throw e;

src/lib/components/atoms/buttons/FileThumbnailButton.svelte

@@ -1,34 +0,0 @@
-<script lang="ts">
-  import { getFileThumbnail } from "$lib/modules/file";
-  import type { SummarizedFileInfo } from "$lib/modules/filesystem";
-
-  import IconFavorite from "~icons/material-symbols/favorite";
-
-  interface Props {
-    info: SummarizedFileInfo;
-    onclick?: (file: SummarizedFileInfo) => void;
-  }
-
-  let { info, onclick }: Props = $props();
-
-  let thumbnail = $derived(getFileThumbnail(info));
-</script>
-
-<button
-  onclick={onclick && (() => setTimeout(() => onclick(info), 100))}
-  class="relative aspect-square overflow-hidden rounded transition active:scale-95 active:brightness-90"
->
-  {#if $thumbnail}
-    <img src={$thumbnail} alt={info.name} class="h-full w-full object-cover" />
-  {:else}
-    <div class="h-full w-full bg-gray-100"></div>
-  {/if}
-  {#if info.isFavorite}
-    <div class={["absolute bottom-0.5 right-0.5"]}>
-      <IconFavorite
-        class="text-sm text-red-500"
-        style="filter: drop-shadow(0 0 1px white) drop-shadow(0 0 1px white)"
-      />
-    </div>
-  {/if}
-</button>

src/lib/components/atoms/buttons/index.ts

@@ -1,6 +0,0 @@
-export { default as ActionEntryButton } from "./ActionEntryButton.svelte";
-export { default as Button } from "./Button.svelte";
-export { default as EntryButton } from "./EntryButton.svelte";
-export { default as FileThumbnailButton } from "./FileThumbnailButton.svelte";
-export { default as FloatingButton } from "./FloatingButton.svelte";
-export { default as TextButton } from "./TextButton.svelte";

src/lib/components/atoms/divs/index.ts

@@ -1,3 +0,0 @@
-export { default as AdaptiveDiv } from "./AdaptiveDiv.svelte";
-export { default as BottomDiv } from "./BottomDiv.svelte";
-export { default as FullscreenDiv } from "./FullscreenDiv.svelte";

src/lib/components/atoms/index.ts

@@ -1,7 +0,0 @@
-export { default as BottomSheet } from "./BottomSheet.svelte";
-export * from "./buttons";
-export { default as Chip } from "./Chip.svelte";
-export * from "./divs";
-export * from "./inputs";
-export { default as Modal } from "./Modal.svelte";
-export { default as RowVirtualizer } from "./RowVirtualizer.svelte";

src/lib/components/atoms/inputs/index.ts

@@ -1,2 +0,0 @@
-export { default as CheckBox } from "./CheckBox.svelte";
-export { default as TextInput } from "./TextInput.svelte";

src/lib/components/molecules/index.ts

@@ -1,9 +0,0 @@
-export * from "./ActionModal.svelte";
-export { default as ActionModal } from "./ActionModal.svelte";
-export * from "./Categories.svelte";
-export { default as Categories } from "./Categories.svelte";
-export { default as IconEntryButton } from "./IconEntryButton.svelte";
-export * from "./labels";
-export { default as SubCategories } from "./SubCategories.svelte";
-export { default as TitledDiv } from "./TitledDiv.svelte";
-export { default as TopBar } from "./TopBar.svelte";

src/lib/components/molecules/labels/index.ts

@@ -1,4 +0,0 @@
-export { default as CategoryLabel } from "./CategoryLabel.svelte";
-export { default as DirectoryEntryLabel } from "./DirectoryEntryLabel.svelte";
-export { default as IconLabel } from "./IconLabel.svelte";
-export { default as TitleLabel } from "./TitleLabel.svelte";

src/lib/components/organisms/index.ts

@@ -1 +0,0 @@
-export * from "./modals";

src/lib/components/organisms/modals/index.ts

@@ -1,4 +0,0 @@
-export { default as CategoryCreateModal } from "./CategoryCreateModal.svelte";
-export { default as ForceLoginModal } from "./ForceLoginModal.svelte";
-export { default as RenameModal } from "./RenameModal.svelte";
-export { default as TextInputModal } from "./TextInputModal.svelte";

src/lib/constants/index.ts

@@ -1,2 +0,0 @@
-export * from "./serviceWorker";
-export * from "./upload";

src/lib/constants/serviceWorker.ts

@@ -1 +0,0 @@
-export const DECRYPTED_FILE_URL_PREFIX = "/_internal/decryptedFile/";

src/lib/constants/upload.ts

@@ -1,9 +0,0 @@
-export const AES_GCM_IV_SIZE = 12;
-export const AES_GCM_TAG_SIZE = 16;
-export const ENCRYPTION_OVERHEAD = AES_GCM_IV_SIZE + AES_GCM_TAG_SIZE;
-
-export const CHUNK_SIZE = 4 * 1024 * 1024; // 4 MiB
-export const ENCRYPTED_CHUNK_SIZE = CHUNK_SIZE + ENCRYPTION_OVERHEAD;
-
-export const MAX_FILE_SIZE = 512 * 1024 * 1024; // 512 MiB
-export const MAX_CHUNKS = Math.ceil(MAX_FILE_SIZE / CHUNK_SIZE); // 128 chunks

src/lib/features/auth/components/ForceLoginModal.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { ActionModal } from "$lib/components/molecules";
+  import { ActionModal } from "#lib/ui/index.ts";
 
   interface Props {
     isOpen: boolean;

src/lib/features/auth/components/index.ts

@@ -0,0 +1 @@
+export { default as ForceLoginModal } from "./ForceLoginModal.svelte";

src/lib/features/auth/index.ts

@@ -0,0 +1,13 @@
+import { trpc } from "#trpc/client.ts";
+
+export const login = async (email: string, password: string) => {
+  await trpc.auth.login.mutate({ email, password });
+};
+
+export const logout = async () => {
+  await trpc.auth.logout.mutate();
+};
+
+export const changePassword = async (oldPassword: string, newPassword: string) => {
+  await trpc.auth.changePassword.mutate({ oldPassword, newPassword });
+};

src/lib/features/errors.ts

@@ -0,0 +1,30 @@
+import { showToast } from "#lib/ui/index.ts";
+import { isTRPCClientError } from "#trpc/client.ts";
+
+const getErrorMessage = (e: unknown, fallbackMessage: string) => {
+  if (isTRPCClientError(e)) {
+    switch (e.data?.code) {
+      case "NOT_FOUND":
+        return "대상을 찾을 수 없어요. 이미 삭제되었을 수 있어요.";
+      case undefined:
+        return "서버에 연결할 수 없어요.";
+    }
+  }
+  return fallbackMessage;
+};
+
+export const showErrorToast = (e: unknown, fallbackMessage: string) => {
+  console.error(e);
+  showToast(getErrorMessage(e, fallbackMessage));
+};
+
+// Runs the action and shows the error to the user if it fails. Returns whether it succeeded.
+export const tryAction = async (action: () => Promise<unknown>, errorMessage: string) => {
+  try {
+    await action();
+    return true;
+  } catch (e) {
+    showErrorToast(e, errorMessage);
+    return false;
+  }
+};

src/lib/features/favorites/index.ts

@@ -0,0 +1,54 @@
+import {
+  getDirectoryInfo,
+  getFileInfo,
+  isExistingFileInfo,
+  isLocalDirectoryInfo,
+  setDirectoryFavorite,
+  setFileFavorite,
+  type LocalDirectoryInfo,
+  type SummarizedFileInfo,
+} from "#lib/features/filesystem/index.ts";
+import { sortEntries } from "#lib/utils/index.ts";
+import { trpc } from "#trpc/client.ts";
+
+export type FavoriteEntry =
+  | { type: "directory"; name: string; details: LocalDirectoryInfo }
+  | { type: "file"; name: string; details: SummarizedFileInfo };
+
+export const getFavoriteEntries = async () => {
+  const favorites = await trpc.favorites.get.query();
+  const [directories, files] = await Promise.all([
+    Promise.all(
+      favorites.directories.map((directory) =>
+        getDirectoryInfo(directory.id, { serverResponse: { ...directory, isFavorite: true } }),
+      ),
+    ),
+    Promise.all(
+      favorites.files.map((file) =>
+        getFileInfo(file.id, { serverResponse: { ...file, isFavorite: true } }),
+      ),
+    ),
+  ]);
+  return [
+    ...sortEntries(
+      directories.filter(isLocalDirectoryInfo).map((directory): FavoriteEntry => ({
+        type: "directory",
+        name: directory.name,
+        details: directory,
+      })),
+    ),
+    ...sortEntries(
+      files
+        .filter(isExistingFileInfo)
+        .map((file): FavoriteEntry => ({ type: "file", name: file.name, details: file })),
+    ),
+  ];
+};
+
+export const removeFavorite = async ({ type, details }: FavoriteEntry) => {
+  if (type === "directory") {
+    await setDirectoryFavorite(details, false);
+  } else {
+    await setFileFavorite(details, false);
+  }
+};

src/lib/features/filesystem/cache.svelte.ts

@@ -0,0 +1,150 @@
+/* eslint-disable svelte/prefer-svelte-reactivity -- Lookup tables of reactive entries */
+import { untrack } from "svelte";
+
+interface FilesystemCacheOptions<K, V> {
+  fetchFromIndexedDB: (key: K) => Promise<V | undefined>;
+  fetchFromServer: (key: K, cachedValue: V | undefined) => Promise<V>;
+  bulkFetchFromIndexedDB?: (keys: Set<K>) => Promise<Map<K, V>>;
+  bulkFetchFromServer?: (keys: Map<K, { cachedValue: V | undefined }>) => Promise<Map<K, V>>;
+}
+
+interface Entry<V> {
+  value?: V;
+  promise?: Promise<V>;
+  isInvalidated: boolean;
+}
+
+// Caches filesystem entries as reactive objects which are updated in place, so that every view
+// of an entry reflects its latest state. Values are first loaded from IndexedDB (if any) and then
+// revalidated against the server.
+export class FilesystemCache<K, V extends object> {
+  private map = new Map<K, Entry<V>>();
+
+  constructor(private readonly options: FilesystemCacheOptions<K, V>) {}
+
+  private getOrCreateEntry(key: K) {
+    let entry = this.map.get(key);
+    if (!entry) {
+      const newEntry: Entry<V> = $state({ isInvalidated: false });
+      entry = newEntry;
+      this.map.set(key, entry);
+    }
+    return entry;
+  }
+
+  private settle(entry: Entry<V>, value: V) {
+    if (entry.value) {
+      Object.assign(entry.value, value);
+    } else {
+      entry.value = value;
+    }
+    return entry.value!;
+  }
+
+  private finish(key: K, entry: Entry<V>) {
+    entry.promise = undefined;
+    // Mutations may invalidate the entry while it is being revalidated, in which case it is queried
+    // again unless it was evicted or replaced in the meantime
+    if (entry.isInvalidated && this.map.get(key) === entry) {
+      void Promise.resolve(this.get(key)).catch(() => {});
+    }
+  }
+
+  // Returns the cached value synchronously if available, and revalidates it in the background
+  get(key: K, options?: { fetchFromServer?: (cachedValue: V | undefined) => Promise<V> }) {
+    return untrack(() => {
+      const entry = this.getOrCreateEntry(key);
+      if (entry.promise) return entry.value ?? entry.promise;
+
+      const { promise, resolve, reject } = Promise.withResolvers<V>();
+      promise.catch(() => {}); // Rejections are handled by callers waiting for the promise
+      entry.promise = promise;
+      entry.isInvalidated = false;
+
+      (async () => {
+        let cachedValue = entry.value && ($state.snapshot(entry.value) as V);
+        if (!cachedValue) {
+          cachedValue = await this.options.fetchFromIndexedDB(key);
+          if (cachedValue) {
+            resolve(this.settle(entry, cachedValue));
+          }
+        }
+
+        const loadedValue = await (options?.fetchFromServer?.(cachedValue) ??
+          this.options.fetchFromServer(key, cachedValue));
+        resolve(this.settle(entry, loadedValue));
+      })()
+        .catch((e) => {
+          console.error(e);
+          reject(e);
+        })
+        .finally(() => this.finish(key, entry));
+
+      return entry.value ?? promise;
+    });
+  }
+
+  bulkGet(keys: Set<K>) {
+    return untrack(() => {
+      const entries = new Map<K, Entry<V>>();
+      const pending = new Map<K, PromiseWithResolvers<V>>();
+      for (const key of keys) {
+        const entry = this.getOrCreateEntry(key);
+        entries.set(key, entry);
+        if (entry.promise) continue;
+
+        const resolvers = Promise.withResolvers<V>();
+        resolvers.promise.catch(() => {});
+        entry.promise = resolvers.promise;
+        entry.isInvalidated = false;
+        pending.set(key, resolvers);
+      }
+
+      const settleAll = (values: Map<K, V>) => {
+        values.forEach((value, key) => {
+          pending.get(key)?.resolve(this.settle(entries.get(key)!, value));
+        });
+      };
+
+      (async () => {
+        const pendingKeys = [...pending.keys()];
+        settleAll(
+          await this.options.bulkFetchFromIndexedDB!(
+            new Set(pendingKeys.filter((key) => !entries.get(key)!.value)),
+          ),
+        );
+        settleAll(
+          await this.options.bulkFetchFromServer!(
+            new Map(pendingKeys.map((key) => [key, { cachedValue: entries.get(key)!.value }])),
+          ),
+        );
+      })()
+        .catch((e) => {
+          console.error(e);
+          pending.forEach(({ reject }) => reject(e));
+        })
+        .finally(() => {
+          pending.forEach((_, key) => this.finish(key, entries.get(key)!));
+        });
+
+      const makeResult = () => new Map([...entries].map(([key, entry]) => [key, entry.value!]));
+      const waiting = [...entries.values()]
+        .filter((entry) => !entry.value)
+        .map((entry) => entry.promise!);
+      return waiting.length > 0 ? Promise.all(waiting).then(makeResult) : makeResult();
+    });
+  }
+
+  // Revalidates the entry if it has been loaded
+  invalidate(key: K) {
+    const entry = this.map.get(key);
+    if (entry) {
+      entry.isInvalidated = true;
+      void Promise.resolve(this.get(key)).catch(() => {});
+    }
+  }
+
+  evict(key: K) {
+    this.map.delete(key);
+  }
+}

src/lib/features/filesystem/category.ts

@@ -0,0 +1,168 @@
+import * as IndexedDB from "#lib/client/storage/indexed-db/index.ts";
+import { isTRPCClientError, trpc } from "#trpc/client.ts";
+import { FilesystemCache } from "./cache.svelte.ts";
+import { invalidateFile } from "./file.ts";
+import { toCategoryInfo, toFileInfo } from "./dto.ts";
+import { encryptName, generateEntryKeys } from "./metadata.ts";
+import { useResource } from "./resource.svelte.ts";
+import type { CategoryInfo, DataKey, LocalCategoryInfo, MaybeCategoryInfo } from "./types.ts";
+
+const cache = new FilesystemCache<CategoryId, MaybeCategoryInfo>({
+  async fetchFromIndexedDB(id) {
+    const [category, subCategories] = await Promise.all([
+      id !== "root" ? IndexedDB.getCategoryInfo(id) : undefined,
+      IndexedDB.getCategoryInfos(id),
+    ]);
+    const files = category?.files
+      ? await Promise.all(
+          category.files.map(async (file) => {
+            const fileInfo = await IndexedDB.getFileInfo(file.id);
+            return fileInfo
+              ? {
+                  id: file.id,
+                  parentId: fileInfo.parentId,
+                  contentType: fileInfo.contentType,
+                  name: fileInfo.name,
+                  createdAt: fileInfo.createdAt,
+                  lastModifiedAt: fileInfo.lastModifiedAt,
+                  isFavorite: fileInfo.isFavorite,
+                  isRecursive: file.isRecursive,
+                }
+              : undefined;
+          }),
+        )
+      : undefined;
+
+    if (id === "root") {
+      return {
+        id,
+        exists: true,
+        subCategories,
+      };
+    } else if (category) {
+      return {
+        id,
+        exists: true,
+        parentId: category.parentId,
+        name: category.name,
+        subCategories,
+        files: files?.filter((file) => !!file) ?? [],
+        isFileRecursive: category.isFileRecursive ?? false,
+      };
+    }
+  },
+
+  async fetchFromServer(id, cachedInfo) {
+    try {
+      const category = await trpc.category.get.query({ id, recurse: true });
+      const [subCategories, files, metadata] = await Promise.all([
+        Promise.all(category.subCategories.map(toCategoryInfo)),
+        Promise.all(
+          (category.files ?? []).map(async (file) => ({
+            ...(await toFileInfo(file)),
+            isRecursive: file.isRecursive,
+          })),
+        ),
+        category.metadata && toCategoryInfo(category.metadata),
+      ]);
+
+      return storeToIndexedDB(
+        metadata
+          ? {
+              ...metadata,
+              subCategories,
+              files,
+              isFileRecursive: cachedInfo?.isFileRecursive ?? false,
+            }
+          : { id: "root", subCategories },
+      );
+    } catch (e) {
+      if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
+        await IndexedDB.deleteCategoryInfo(id as number);
+        return { id, exists: false };
+      }
+      throw e;
+    }
+  },
+});
+
+const storeToIndexedDB = (info: CategoryInfo) => {
+  if (info.id !== "root") {
+    void IndexedDB.storeCategoryInfo(info);
+
+    // TODO: Bulk Upsert
+    new Map(info.files.map((file) => [file.id, file])).forEach((file) => {
+      void IndexedDB.storeFileInfo(file);
+    });
+  }
+
+  // TODO: Bulk Upsert
+  info.subCategories.forEach((category) => {
+    void IndexedDB.storeCategoryInfo(category);
+  });
+
+  void IndexedDB.deleteDanglingCategoryInfos(
+    info.id,
+    new Set(info.subCategories.map(({ id }) => id)),
+  );
+
+  return { ...info, exists: true as const };
+};
+
+export const getCategoryInfo = (id: CategoryId) => {
+  return cache.get(id);
+};
+
+export const useCategory = (getId: () => CategoryId) => {
+  return useResource(getId, (id) => getCategoryInfo(id));
+};
+
+export const invalidateCategory = (id: CategoryId) => {
+  cache.invalidate(id);
+};
+
+export const createCategory = async (parentId: CategoryId, name: string) => {
+  await trpc.category.create.mutate({ parent: parentId, ...(await generateEntryKeys(name)) });
+  invalidateCategory(parentId);
+};
+
+export const renameCategory = async (
+  category: { id: number; parentId: CategoryId; dataKey?: DataKey },
+  newName: string,
+) => {
+  if (!category.dataKey) {
+    throw new Error("Data key not loaded");
+  }
+
+  await trpc.category.rename.mutate({
+    id: category.id,
+    dekVersion: category.dataKey.version,
+    ...(await encryptName(newName, category.dataKey.key)),
+  });
+  invalidateCategory(category.parentId);
+  invalidateCategory(category.id);
+};
+
+export const deleteCategory = async (category: { id: number; parentId: CategoryId }) => {
+  await trpc.category.delete.mutate({ id: category.id });
+  cache.evict(category.id);
+  invalidateCategory(category.parentId);
+};
+
+export const addFileToCategory = async (fileId: number, categoryId: number) => {
+  await trpc.category.addFile.mutate({ id: categoryId, file: fileId });
+  invalidateFile(fileId);
+  invalidateCategory(categoryId);
+};
+
+export const removeFileFromCategory = async (fileId: number, categoryId: number) => {
+  await trpc.category.removeFile.mutate({ id: categoryId, file: fileId });
+  invalidateFile(fileId);
+  invalidateCategory(categoryId);
+};
+
+// Whether to show the files of subcategories is a local preference
+export const setCategoryFileRecursive = async (category: LocalCategoryInfo, value: boolean) => {
+  category.isFileRecursive = value;
+  await IndexedDB.updateCategoryInfo(category.id, { isFileRecursive: value });
+};

src/lib/features/filesystem/components/Categories.svelte

@@ -1,5 +1,5 @@
 <script module lang="ts">
-  import type { DataKey } from "$lib/modules/filesystem";
+  import type { DataKey, SubCategoryInfo } from "#lib/features/filesystem/index.ts";
 
   export interface SelectedCategory {
     id: number;
@@ -11,10 +11,8 @@
 <script lang="ts">
   import type { Component } from "svelte";
   import type { SvelteHTMLElements } from "svelte/elements";
-  import { ActionEntryButton } from "$lib/components/atoms";
+  import { ActionEntryButton, CategoryLabel } from "#lib/ui/index.ts";
-  import { CategoryLabel } from "$lib/components/molecules";
+  import { sortEntries } from "#lib/utils/index.ts";
-  import type { SubCategoryInfo } from "$lib/modules/filesystem";
-  import { sortEntries } from "$lib/utils";
 
   interface Props {
     categories: SubCategoryInfo[];

src/lib/features/filesystem/components/CategoryCreateModal.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { TextInputModal } from "$lib/components/organisms";
+  import { TextInputModal } from "#lib/ui/index.ts";
 
   interface Props {
     isOpen: boolean;

src/lib/features/filesystem/components/DirectoryEntry.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+  import type { Component } from "svelte";
+  import type { SvelteHTMLElements } from "svelte/elements";
+  import { ActionEntryButton, DirectoryEntryLabel } from "#lib/ui/index.ts";
+
+  interface Props {
+    action?: {
+      icon: Component<SvelteHTMLElements["svg"]>;
+      onclick: () => void;
+    };
+    info: { name: string; isFavorite?: boolean };
+    onclick?: () => void;
+  }
+
+  let { action, info, onclick }: Props = $props();
+</script>
+
+<ActionEntryButton
+  class="h-14"
+  {onclick}
+  actionButtonIcon={action?.icon}
+  onActionButtonClick={action?.onclick}
+>
+  <DirectoryEntryLabel type="directory" name={info.name} isFavorite={info.isFavorite} />
+</ActionEntryButton>

src/lib/features/filesystem/components/FileEntry.svelte

@@ -0,0 +1,40 @@
+<script lang="ts">
+  import type { Component } from "svelte";
+  import type { ClassValue, SvelteHTMLElements } from "svelte/elements";
+  import { getFileThumbnail } from "#lib/client/cache/index.ts";
+  import { ActionEntryButton, DirectoryEntryLabel } from "#lib/ui/index.ts";
+  import { formatDateTime } from "#lib/utils/index.ts";
+  import type { SummarizedFileInfo } from "../types.ts";
+
+  interface Props {
+    action?: {
+      icon: Component<SvelteHTMLElements["svg"]>;
+      onclick: () => void;
+      class?: ClassValue;
+    };
+    info: SummarizedFileInfo;
+    onclick?: () => void;
+    showThumbnail?: boolean;
+    subtext?: string;
+  }
+
+  let { action, info, onclick, showThumbnail = true, subtext }: Props = $props();
+
+  let thumbnail = $derived(showThumbnail ? getFileThumbnail(info) : undefined);
+</script>
+
+<ActionEntryButton
+  class="h-14"
+  {onclick}
+  actionButtonIcon={action?.icon}
+  actionButtonClass={action?.class}
+  onActionButtonClick={action?.onclick}
+>
+  <DirectoryEntryLabel
+    type="file"
+    thumbnail={thumbnail?.url}
+    name={info.name}
+    subtext={subtext ?? formatDateTime(info.createdAt ?? info.lastModifiedAt)}
+    isFavorite={info.isFavorite}
+  />
+</ActionEntryButton>

src/lib/features/filesystem/components/FileThumbnailButton.svelte

@@ -0,0 +1,35 @@
+<script lang="ts">
+  import { getFileThumbnail } from "#lib/client/cache/index.ts";
+  import type { SummarizedFileInfo } from "#lib/features/filesystem/index.ts";
+  import { afterPress } from "#lib/ui/index.ts";
+
+  import IconFavorite from "~icons/material-symbols/favorite";
+
+  interface Props {
+    info: SummarizedFileInfo;
+    onclick?: (file: SummarizedFileInfo) => void;
+  }
+
+  let { info, onclick }: Props = $props();
+
+  let thumbnail = $derived(getFileThumbnail(info));
+</script>
+
+<button
+  onclick={afterPress(onclick && (() => onclick(info)))}
+  class="relative aspect-square overflow-hidden rounded-sm transition active:scale-95 active:brightness-90"
+>
+  {#if thumbnail?.url}
+    <img src={thumbnail?.url} alt={info.name} class="size-full object-cover" />
+  {:else}
+    <div class="size-full bg-gray-100"></div>
+  {/if}
+  {#if info.isFavorite}
+    <div class={["absolute right-0.5 bottom-0.5"]}>
+      <IconFavorite
+        class="text-sm text-red-500"
+        style="filter: drop-shadow(0 0 1px white) drop-shadow(0 0 1px white)"
+      />
+    </div>
+  {/if}
+</button>

src/lib/features/filesystem/components/SubCategories.svelte

@@ -1,8 +1,9 @@
 <script lang="ts">
   import type { Component } from "svelte";
   import type { ClassValue, SvelteHTMLElements } from "svelte/elements";
-  import { Categories, IconEntryButton, type SelectedCategory } from "$lib/components/molecules";
+  import { Categories, type SelectedCategory } from "#lib/features/filesystem/components/index.ts";
-  import type { CategoryInfo } from "$lib/modules/filesystem";
+  import type { CategoryInfo } from "#lib/features/filesystem/index.ts";
+  import { IconEntryButton } from "#lib/ui/index.ts";
 
   import IconAddCircle from "~icons/material-symbols/add-circle";
 

src/lib/features/filesystem/components/index.ts

@@ -0,0 +1,7 @@
+export * from "./Categories.svelte";
+export { default as Categories } from "./Categories.svelte";
+export { default as CategoryCreateModal } from "./CategoryCreateModal.svelte";
+export { default as DirectoryEntry } from "./DirectoryEntry.svelte";
+export { default as FileEntry } from "./FileEntry.svelte";
+export { default as FileThumbnailButton } from "./FileThumbnailButton.svelte";
+export { default as SubCategories } from "./SubCategories.svelte";

src/lib/features/filesystem/content.ts

@@ -0,0 +1,67 @@
+import {
+  deleteFileCache,
+  deleteFileThumbnailCache,
+  storeFileThumbnailCache,
+} from "#lib/client/cache/index.ts";
+import {
+  getDecryptedFileUrl,
+  prepareFileDecryption,
+  saveDecryptedFile,
+} from "#lib/client/service-worker.ts";
+import { getAllFileInfos } from "#lib/client/storage/indexed-db/index.ts";
+import { uploadBlob } from "#lib/client/transfer/chunked-upload.ts";
+import { trpc } from "#trpc/client.ts";
+import type { DataKey } from "./types.ts";
+
+interface StreamableFile {
+  id: number;
+  isLegacy?: boolean;
+  dataKey?: DataKey;
+  contentType: string;
+}
+
+// Returns a URL from which the service worker streams the decrypted content of the file
+export const getFileStreamUrl = async ({ id, isLegacy, dataKey, contentType }: StreamableFile) => {
+  if (!dataKey) {
+    throw new Error("Data key not loaded");
+  }
+
+  await prepareFileDecryption(id, { isLegacy: !!isLegacy, dataKey: dataKey.key, contentType });
+  return getDecryptedFileUrl(id);
+};
+
+export const getFileBlob = async (file: StreamableFile) => {
+  const res = await fetch(await getFileStreamUrl(file));
+  if (!res.ok) {
+    throw new Error("Failed to download the file");
+  }
+  return await res.blob();
+};
+
+export const saveFile = async (file: StreamableFile & { name: string }) => {
+  await getFileStreamUrl(file);
+  saveDecryptedFile(file.id, file.name);
+};
+
+export const uploadFileThumbnail = async (fileId: number, thumbnail: Blob, dataKey: DataKey) => {
+  const { uploadId } = await trpc.upload.startFileThumbnailUpload.mutate({
+    file: fileId,
+    dekVersion: dataKey.version,
+  });
+  await uploadBlob(uploadId, thumbnail, dataKey.key);
+  await trpc.upload.completeFileThumbnailUpload.mutate({ uploadId });
+
+  await storeFileThumbnailCache(fileId, await thumbnail.arrayBuffer());
+};
+
+// Deletes local caches of files deleted on other devices
+export const cleanupDeletedFileCaches = async () => {
+  const liveFiles = new Set(await trpc.file.list.query());
+  const maybeCachedFiles = await getAllFileInfos();
+
+  await Promise.all(
+    maybeCachedFiles
+      .filter(({ id }) => !liveFiles.has(id))
+      .flatMap(({ id }) => [deleteFileCache(id), deleteFileThumbnailCache(id)]),
+  );
+};

src/lib/features/filesystem/directory.ts

@@ -0,0 +1,151 @@
+import { deleteFileCache, deleteFileThumbnailCache } from "#lib/client/cache/index.ts";
+import * as IndexedDB from "#lib/client/storage/indexed-db/index.ts";
+import { isTRPCClientError, trpc } from "#trpc/client.ts";
+import { FilesystemCache } from "./cache.svelte.ts";
+import { toDirectoryInfo, toFileInfo, type DirectoryDto } from "./dto.ts";
+import { encryptName, generateEntryKeys } from "./metadata.ts";
+import { useResource } from "./resource.svelte.ts";
+import type { DataKey, DirectoryInfo, MaybeDirectoryInfo } from "./types.ts";
+
+const cache = new FilesystemCache<DirectoryId, MaybeDirectoryInfo>({
+  async fetchFromIndexedDB(id) {
+    const [directory, subDirectories, files] = await Promise.all([
+      id !== "root" ? IndexedDB.getDirectoryInfo(id) : undefined,
+      IndexedDB.getDirectoryInfos(id),
+      IndexedDB.getFileInfos(id),
+    ]);
+
+    if (id === "root") {
+      return {
+        id,
+        exists: true,
+        subDirectories,
+        files,
+      };
+    } else if (directory) {
+      return {
+        id,
+        exists: true,
+        parentId: directory.parentId,
+        name: directory.name,
+        subDirectories,
+        files,
+        isFavorite: directory.isFavorite,
+      };
+    }
+  },
+
+  async fetchFromServer(id) {
+    try {
+      const directory = await trpc.directory.get.query({ id });
+      const [subDirectories, files, metadata] = await Promise.all([
+        Promise.all(directory.subDirectories.map(toDirectoryInfo)),
+        Promise.all(directory.files.map(toFileInfo)),
+        directory.metadata && toDirectoryInfo(directory.metadata),
+      ]);
+
+      return storeToIndexedDB(
+        metadata ? { ...metadata, subDirectories, files } : { id: "root", subDirectories, files },
+      );
+    } catch (e) {
+      if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
+        await IndexedDB.deleteDirectoryInfo(id as number);
+        return { id, exists: false as const };
+      }
+      throw e;
+    }
+  },
+});
+
+const storeToIndexedDB = (info: DirectoryInfo) => {
+  if (info.id !== "root") {
+    void IndexedDB.storeDirectoryInfo(info);
+  }
+
+  // TODO: Bulk Upsert
+  info.subDirectories.forEach((subDirectory) => {
+    void IndexedDB.storeDirectoryInfo(subDirectory);
+  });
+
+  // TODO: Bulk Upsert
+  info.files.forEach((file) => {
+    void IndexedDB.storeFileInfo(file);
+  });
+
+  void IndexedDB.deleteDanglingDirectoryInfos(
+    info.id,
+    new Set(info.subDirectories.map(({ id }) => id)),
+  );
+  void IndexedDB.deleteDanglingFileInfos(info.id, new Set(info.files.map(({ id }) => id)));
+
+  return { ...info, exists: true as const };
+};
+
+// Uses `serverResponse` instead of fetching the directory from the server if given
+export const getDirectoryInfo = (id: DirectoryId, options?: { serverResponse?: DirectoryDto }) => {
+  const serverResponse = options?.serverResponse;
+  return cache.get(id, {
+    fetchFromServer:
+      serverResponse &&
+      (async (cachedValue) =>
+        storeToIndexedDB({
+          subDirectories: [],
+          files: [],
+          ...cachedValue,
+          ...(await toDirectoryInfo(serverResponse)),
+        })),
+  });
+};
+
+export const useDirectory = (getId: () => DirectoryId) => {
+  return useResource(getId, (id) => getDirectoryInfo(id));
+};
+
+export const invalidateDirectory = (id: DirectoryId) => {
+  cache.invalidate(id);
+};
+
+export const createDirectory = async (parentId: DirectoryId, name: string) => {
+  await trpc.directory.create.mutate({ parent: parentId, ...(await generateEntryKeys(name)) });
+  invalidateDirectory(parentId);
+};
+
+export const renameDirectory = async (
+  directory: { id: number; parentId: DirectoryId; dataKey?: DataKey },
+  newName: string,
+) => {
+  if (!directory.dataKey) {
+    throw new Error("Data key not loaded");
+  }
+
+  await trpc.directory.rename.mutate({
+    id: directory.id,
+    dekVersion: directory.dataKey.version,
+    ...(await encryptName(newName, directory.dataKey.key)),
+  });
+  invalidateDirectory(directory.parentId);
+  invalidateDirectory(directory.id);
+};
+
+export const deleteDirectory = async (directory: { id: number; parentId: DirectoryId }) => {
+  const { deletedFiles } = await trpc.directory.delete.mutate({ id: directory.id });
+  cache.evict(directory.id);
+  invalidateDirectory(directory.parentId);
+
+  await Promise.all(
+    deletedFiles.flatMap((fileId) => [deleteFileCache(fileId), deleteFileThumbnailCache(fileId)]),
+  );
+};
+
+export const setDirectoryFavorite = async (
+  directory: { id: number; parentId: DirectoryId },
+  isFavorite: boolean,
+) => {
+  if (isFavorite) {
+    await trpc.favorites.addDirectory.mutate({ id: directory.id });
+  } else {
+    await trpc.favorites.removeDirectory.mutate({ id: directory.id });
+  }
+  invalidateDirectory(directory.parentId);
+  invalidateDirectory(directory.id);
+};

src/lib/features/filesystem/dto.ts

@@ -0,0 +1,46 @@
+import type { RouterOutputs } from "#trpc/router.server.ts";
+import {
+  decryptCategoryMetadata,
+  decryptDirectoryMetadata,
+  decryptFileMetadata,
+} from "./metadata.ts";
+import type { FileInfo, SubCategoryInfo, SubDirectoryInfo, SummarizedFileInfo } from "./types.ts";
+
+// Shapes of filesystem entries returned by the server
+export type DirectoryDto = RouterOutputs["directory"]["get"]["subDirectories"][number];
+export type FileDto = RouterOutputs["directory"]["get"]["files"][number];
+export type CategoryDto = RouterOutputs["category"]["get"]["subCategories"][number];
+export type FileWithCategoriesDto = RouterOutputs["file"]["get"];
+
+export const toDirectoryInfo = async (directory: DirectoryDto): Promise<SubDirectoryInfo> => ({
+  id: directory.id,
+  parentId: directory.parent,
+  isFavorite: directory.isFavorite,
+  ...(await decryptDirectoryMetadata(directory)),
+});
+
+export const toFileInfo = async (file: FileDto): Promise<SummarizedFileInfo> => ({
+  id: file.id,
+  isLegacy: file.isLegacy,
+  parentId: file.parent,
+  contentType: file.contentType,
+  isFavorite: file.isFavorite,
+  ...(await decryptFileMetadata(file)),
+});
+
+export const toCategoryInfo = async (category: CategoryDto): Promise<SubCategoryInfo> => ({
+  id: category.id,
+  parentId: category.parent,
+  ...(await decryptCategoryMetadata(category)),
+});
+
+export const toFileWithCategoriesInfo = async ({
+  categories,
+  ...file
+}: FileWithCategoriesDto): Promise<FileInfo> => {
+  const [fileInfo, categoryInfos] = await Promise.all([
+    toFileInfo(file),
+    Promise.all(categories.map(toCategoryInfo)),
+  ]);
+  return { ...fileInfo, categories: categoryInfos };
+};

src/lib/features/filesystem/file.ts

@@ -0,0 +1,196 @@
+import { deleteFileCache, deleteFileThumbnailCache } from "#lib/client/cache/index.ts";
+import * as IndexedDB from "#lib/client/storage/indexed-db/index.ts";
+import { isTRPCClientError, trpc } from "#trpc/client.ts";
+import { FilesystemCache } from "./cache.svelte.ts";
+import { invalidateDirectory } from "./directory.ts";
+import { toFileInfo, toFileWithCategoriesInfo, type FileDto } from "./dto.ts";
+import { encryptName } from "./metadata.ts";
+import { useResource } from "./resource.svelte.ts";
+import type { DataKey, FileInfo, MaybeFileInfo } from "./types.ts";
+
+// Categories of files stored in IndexedDB, which may have been deleted
+const getFileCategoryInfos = async (categoryIds: number[] | undefined) => {
+  const categories = await Promise.all(
+    (categoryIds ?? []).map((id) => IndexedDB.getCategoryInfo(id)),
+  );
+  return categories
+    .filter((category) => !!category)
+    .map(({ id, parentId, name }) => ({ id, parentId, name }));
+};
+
+const cache = new FilesystemCache<number, MaybeFileInfo>({
+  async fetchFromIndexedDB(id) {
+    const file = await IndexedDB.getFileInfo(id);
+    if (file) {
+      return {
+        id,
+        exists: true,
+        parentId: file.parentId,
+        contentType: file.contentType,
+        name: file.name,
+        createdAt: file.createdAt,
+        lastModifiedAt: file.lastModifiedAt,
+        categories: await getFileCategoryInfos(file.categoryIds),
+        isFavorite: file.isFavorite,
+      };
+    }
+  },
+
+  async fetchFromServer(id) {
+    try {
+      return storeToIndexedDB(await toFileWithCategoriesInfo(await trpc.file.get.query({ id })));
+    } catch (e) {
+      if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
+        await IndexedDB.deleteFileInfo(id);
+        return { id, exists: false as const };
+      }
+      throw e;
+    }
+  },
+
+  async bulkFetchFromIndexedDB(ids) {
+    const files = (await IndexedDB.bulkGetFileInfos([...ids])).filter((file) => !!file);
+    return new Map(
+      await Promise.all(
+        files.map(
+          async (file) =>
+            [
+              file.id,
+              {
+                ...file,
+                exists: true as const,
+                categories: await getFileCategoryInfos(file.categoryIds),
+              },
+            ] as const,
+        ),
+      ),
+    );
+  },
+
+  async bulkFetchFromServer(ids) {
+    const idsArray = [...ids.keys()];
+
+    const filesRaw = await trpc.file.bulkGet.query({ ids: idsArray });
+    const files = await Promise.all(filesRaw.map(toFileWithCategoriesInfo));
+
+    const existingIds = new Set(filesRaw.map(({ id }) => id));
+    const deletedIds = idsArray.filter((id) => !existingIds.has(id));
+
+    void IndexedDB.bulkDeleteFileInfos(deletedIds);
+    return new Map<number, MaybeFileInfo>([
+      ...bulkStoreToIndexedDB(files),
+      ...deletedIds.map((id) => [id, { id, exists: false }] as const),
+    ]);
+  },
+});
+
+const storeToIndexedDB = (info: FileInfo) => {
+  void IndexedDB.storeFileInfo({
+    ...info,
+    categoryIds: info.categories.map(({ id }) => id),
+  });
+
+  info.categories.forEach((category) => {
+    void IndexedDB.storeCategoryInfo(category);
+  });
+
+  return { ...info, exists: true as const };
+};
+
+const bulkStoreToIndexedDB = (infos: FileInfo[]) => {
+  // TODO: Bulk Upsert
+  infos.forEach((info) => {
+    void IndexedDB.storeFileInfo({
+      ...info,
+      categoryIds: info.categories.map(({ id }) => id),
+    });
+  });
+
+  // TODO: Bulk Upsert
+  new Map(
+    infos.flatMap(({ categories }) => categories).map((category) => [category.id, category]),
+  ).forEach((category) => {
+    void IndexedDB.storeCategoryInfo(category);
+  });
+
+  return infos.map((info) => [info.id, { ...info, exists: true }] as const);
+};
+
+// Uses `serverResponse` instead of fetching the file from the server if given
+export const getFileInfo = (id: number, options?: { serverResponse?: FileDto }) => {
+  const serverResponse = options?.serverResponse;
+  return cache.get(id, {
+    fetchFromServer:
+      serverResponse &&
+      (async (cachedValue) =>
+        storeToIndexedDB({
+          categories: [],
+          ...cachedValue,
+          ...(await toFileInfo(serverResponse)),
+        })),
+  });
+};
+
+export const bulkGetFileInfo = (ids: number[]) => {
+  return cache.bulkGet(new Set(ids));
+};
+
+export const useFile = (getId: () => number) => {
+  return useResource(getId, (id) => getFileInfo(id));
+};
+
+export const invalidateFile = (id: number) => {
+  cache.invalidate(id);
+};
+
+export const renameFile = async (
+  file: { id: number; parentId: DirectoryId; dataKey?: DataKey },
+  newName: string,
+) => {
+  if (!file.dataKey) {
+    throw new Error("Data key not loaded");
+  }
+
+  await trpc.file.rename.mutate({
+    id: file.id,
+    dekVersion: file.dataKey.version,
+    ...(await encryptName(newName, file.dataKey.key)),
+  });
+  invalidateDirectory(file.parentId);
+  invalidateFile(file.id);
+};
+
+export const deleteFile = async (file: { id: number; parentId: DirectoryId }) => {
+  await trpc.file.delete.mutate({ id: file.id });
+  cache.evict(file.id);
+  invalidateDirectory(file.parentId);
+
+  await Promise.all([deleteFileCache(file.id), deleteFileThumbnailCache(file.id)]);
+};
+
+export const setFileFavorite = async (
+  file: { id: number; parentId: DirectoryId },
+  isFavorite: boolean,
+) => {
+  if (isFavorite) {
+    await trpc.favorites.addFile.mutate({ id: file.id });
+  } else {
+    await trpc.favorites.removeFile.mutate({ id: file.id });
+  }
+  invalidateDirectory(file.parentId);
+  invalidateFile(file.id);
+};
+
+// The most recently created media files among the files stored locally
+export const getRecentMediaFileInfos = async (limit: number) => {
+  const files = await IndexedDB.getAllFileInfos();
+  return files
+    .filter(
+      ({ contentType }) => contentType.startsWith("image/") || contentType.startsWith("video/"),
+    )
+    .sort(
+      (a, b) =>
+        (b.createdAt ?? b.lastModifiedAt).getTime() - (a.createdAt ?? a.lastModifiedAt).getTime(),
+    )
+    .slice(0, limit);
+};

src/lib/features/filesystem/index.ts

@@ -0,0 +1,6 @@
+export * from "./category.ts";
+export * from "./content.ts";
+export * from "./directory.ts";
+export * from "./file.ts";
+export * from "./types.ts";
+export * from "./upload.ts";

src/lib/features/filesystem/metadata.ts

@@ -0,0 +1,83 @@
+import { keyring } from "#lib/client/keys/index.ts";
+import {
+  decryptString,
+  encryptString,
+  generateDataKey,
+  unwrapDataKey,
+  wrapDataKey,
+} from "#lib/shared/crypto/index.ts";
+
+const unwrapEntryDataKey = async (metadata: { mekVersion: number; dek: string }) => {
+  const { dataKey } = await unwrapDataKey(
+    metadata.dek,
+    keyring.getMasterKey(metadata.mekVersion).key,
+  );
+  return dataKey;
+};
+
+export const decryptDirectoryMetadata = async (metadata: {
+  mekVersion: number;
+  dek: string;
+  dekVersion: Date;
+  name: string;
+  nameIv: string;
+}) => {
+  const dataKey = await unwrapEntryDataKey(metadata);
+  const name = await decryptString(metadata.name, metadata.nameIv, dataKey);
+
+  return {
+    dataKey: { key: dataKey, version: metadata.dekVersion },
+    name,
+  };
+};
+
+const decryptDate = async (ciphertext: string, iv: string, dataKey: CryptoKey) => {
+  return new Date(parseInt(await decryptString(ciphertext, iv, dataKey), 10));
+};
+
+export const decryptFileMetadata = async (metadata: {
+  mekVersion: number;
+  dek: string;
+  dekVersion: Date;
+  name: string;
+  nameIv: string;
+  createdAt?: string;
+  createdAtIv?: string;
+  lastModifiedAt: string;
+  lastModifiedAtIv: string;
+}) => {
+  const dataKey = await unwrapEntryDataKey(metadata);
+  const [name, createdAt, lastModifiedAt] = await Promise.all([
+    decryptString(metadata.name, metadata.nameIv, dataKey),
+    metadata.createdAt
+      ? decryptDate(metadata.createdAt, metadata.createdAtIv!, dataKey)
+      : undefined,
+    decryptDate(metadata.lastModifiedAt, metadata.lastModifiedAtIv, dataKey),
+  ]);
+
+  return {
+    dataKey: { key: dataKey, version: metadata.dekVersion },
+    name,
+    createdAt,
+    lastModifiedAt,
+  };
+};
+
+export const decryptCategoryMetadata = decryptDirectoryMetadata;
+
+export const encryptName = async (name: string, dataKey: CryptoKey) => {
+  const { ciphertext, iv } = await encryptString(name, dataKey);
+  return { name: ciphertext, nameIv: iv };
+};
+
+// Generates the keys of a new directory or category encrypted with the active master key
+export const generateEntryKeys = async (name: string) => {
+  const masterKey = keyring.activeMasterKey;
+  const { dataKey, dataKeyVersion } = await generateDataKey();
+  return {
+    mekVersion: masterKey.version,
+    dek: await wrapDataKey(dataKey, masterKey.key),
+    dekVersion: dataKeyVersion,
+    ...(await encryptName(name, dataKey)),
+  };
+};

src/lib/features/filesystem/resource.svelte.ts

@@ -0,0 +1,33 @@
+import { untrack } from "svelte";
+
+// Exposes the value of a cache entry identified by a reactive key. Cached values are available
+// synchronously, so that views don't flicker while revalidating.
+export const useResource = <K, V>(getKey: () => K, load: (key: K) => V | Promise<V>) => {
+  let current: V | undefined = $state();
+
+  $effect.pre(() => {
+    const key = getKey();
+    let isStale = false;
+
+    const result = untrack(() => load(key));
+    if (result instanceof Promise) {
+      result
+        .then((value) => {
+          if (!isStale) current = value;
+        })
+        .catch(() => {}); // Logged by the cache
+    } else {
+      current = result;
+    }
+
+    return () => {
+      isStale = true;
+    };
+  });
+
+  return {
+    get current() {
+      return current;
+    },
+  };
+};

src/lib/features/filesystem/types.ts

@@ -49,7 +49,7 @@ export type CategoryFileInfo = SummarizedFileInfo & { isRecursive: boolean };
 
 export interface LocalCategoryInfo {
   id: number;
-  parentId: DirectoryId;
+  parentId: CategoryId;
   dataKey?: DataKey;
   name: string;
   subCategories: SubCategoryInfo[];
@@ -77,3 +77,10 @@ export type SubCategoryInfo = Omit<
   "subCategories" | "files" | "isFileRecursive"
 >;
 export type FileCategoryInfo = Omit<SubCategoryInfo, "dataKey">;
+
+export const isLocalDirectoryInfo = (
+  info: MaybeDirectoryInfo,
+): info is LocalDirectoryInfo & { exists: true } => info.exists && info.id !== "root";
+
+export const isExistingFileInfo = (info: MaybeFileInfo): info is FileInfo & { exists: true } =>
+  info.exists;

src/lib/features/filesystem/upload.ts

@@ -0,0 +1,19 @@
+import { storeFileThumbnailCache } from "#lib/client/cache/index.ts";
+import { uploadFile as doUploadFile } from "#lib/client/transfer/index.ts";
+import { invalidateDirectory } from "./directory.ts";
+
+// Uploads the file and caches it with its thumbnail locally. Returns `false` if the upload is canceled.
+export const uploadFile = async (
+  file: File,
+  parentId: DirectoryId,
+  onDuplicate: () => Promise<boolean>,
+) => {
+  const res = await doUploadFile(file, parentId, onDuplicate);
+  if (!res) return false;
+
+  invalidateDirectory(parentId);
+  if (res.thumbnailBuffer) {
+    void storeFileThumbnailCache(res.fileId, res.thumbnailBuffer);
+  }
+  return true;
+};

src/lib/features/search/index.ts

@@ -0,0 +1,46 @@
+import {
+  getDirectoryInfo,
+  getFileInfo,
+  isExistingFileInfo,
+  isLocalDirectoryInfo,
+  type FileInfo,
+  type LocalCategoryInfo,
+  type LocalDirectoryInfo,
+} from "#lib/features/filesystem/index.ts";
+import { trpc } from "#trpc/client.ts";
+
+export interface SearchFilter {
+  ancestorId: DirectoryId;
+  inFavorites: boolean;
+  categories: { info: LocalCategoryInfo; type: "include" | "exclude" }[];
+}
+
+export interface SearchResult {
+  directories: LocalDirectoryInfo[];
+  files: FileInfo[];
+}
+
+const getCategoryIds = (filter: SearchFilter, type: "include" | "exclude") => {
+  return filter.categories.filter((category) => category.type === type).map(({ info }) => info.id);
+};
+
+export const search = async (filter: SearchFilter) => {
+  const { directories: directoriesRaw, files: filesRaw } = await trpc.search.search.query({
+    ancestor: filter.ancestorId,
+    inFavorites: filter.inFavorites,
+    includeCategories: getCategoryIds(filter, "include"),
+    excludeCategories: getCategoryIds(filter, "exclude"),
+  });
+  const [directories, files] = await Promise.all([
+    Promise.all(
+      directoriesRaw.map((directory) =>
+        getDirectoryInfo(directory.id, { serverResponse: directory }),
+      ),
+    ),
+    Promise.all(filesRaw.map((file) => getFileInfo(file.id, { serverResponse: file }))),
+  ]);
+  return {
+    directories: directories.filter(isLocalDirectoryInfo),
+    files: files.filter(isExistingFileInfo),
+  } satisfies SearchResult;
+};

src/lib/features/transfer/components/TransferProgress.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">
+  import { formatNetworkSpeed } from "#lib/utils/index.ts";
+
+  interface Props {
+    progress?: number;
+    rate?: number; // Bytes per second
+  }
+
+  let { progress, rate }: Props = $props();
+</script>
+
+전송됨 {Math.floor((progress ?? 0) * 100)}% · {formatNetworkSpeed((rate ?? 0) * 8)}

src/lib/features/transfer/components/UploadStatusText.svelte

@@ -0,0 +1,26 @@
+<script lang="ts">
+  import type { FileUploadState } from "#lib/client/transfer/index.ts";
+  import TransferProgress from "./TransferProgress.svelte";
+
+  interface Props {
+    state: FileUploadState;
+  }
+
+  let { state }: Props = $props();
+
+  const statusTexts = {
+    queued: "대기 중",
+    "encryption-pending": "준비 중",
+    encrypting: "암호화하는 중",
+    "upload-pending": "업로드를 기다리는 중",
+    uploaded: "업로드 완료",
+    canceled: "",
+    error: "업로드 실패",
+  } satisfies Record<Exclude<FileUploadState["status"], "uploading">, string>;
+</script>
+
+{#if state.status === "uploading"}
+  <TransferProgress progress={state.progress} rate={state.rate} />
+{:else}
+  {statusTexts[state.status]}
+{/if}

src/lib/features/transfer/components/index.ts

@@ -0,0 +1,2 @@
+export { default as TransferProgress } from "./TransferProgress.svelte";
+export { default as UploadStatusText } from "./UploadStatusText.svelte";

src/lib/indexedDB/cacheIndex.ts

@@ -1,33 +0,0 @@
-import { Dexie, type EntityTable } from "dexie";
-
-export interface FileCacheIndex {
-  fileId: number;
-  cachedAt: Date;
-  lastRetrievedAt: Date;
-  size: number;
-}
-
-const cacheIndex = new Dexie("cacheIndex") as Dexie & {
-  fileCache: EntityTable<FileCacheIndex, "fileId">;
-};
-
-cacheIndex.version(1).stores({
-  fileCache: "fileId",
-});
-
-export const getFileCacheIndex = async () => {
-  return await cacheIndex.fileCache.toArray();
-};
-
-export const storeFileCacheIndex = async (fileCacheIndex: FileCacheIndex) => {
-  await cacheIndex.fileCache.put({
-    fileId: fileCacheIndex.fileId,
-    cachedAt: fileCacheIndex.cachedAt,
-    lastRetrievedAt: fileCacheIndex.lastRetrievedAt,
-    size: fileCacheIndex.size,
-  });
-};
-
-export const deleteFileCacheIndex = async (fileId: number) => {
-  await cacheIndex.fileCache.delete(fileId);
-};

src/lib/indexedDB/index.ts

@@ -1,3 +0,0 @@
-export * from "./cacheIndex";
-export * from "./filesystem";
-export * from "./keyStore";

src/lib/modules/crypto/index.ts

@@ -1,4 +0,0 @@
-export * from "./aes";
-export * from "./rsa";
-export * from "./sha";
-export * from "./utils";

src/lib/modules/file/cache.ts

@@ -1,50 +0,0 @@
-import {
-  getFileCacheIndex as getFileCacheIndexFromIndexedDB,
-  storeFileCacheIndex,
-  deleteFileCacheIndex,
-  type FileCacheIndex,
-} from "$lib/indexedDB";
-import { readFile, writeFile, deleteFile } from "$lib/modules/opfs";
-
-const fileCacheIndex = new Map<number, FileCacheIndex>();
-
-export const prepareFileCache = async () => {
-  for (const cache of await getFileCacheIndexFromIndexedDB()) {
-    fileCacheIndex.set(cache.fileId, cache);
-  }
-};
-
-export const getFileCacheIndex = () => {
-  return Array.from(fileCacheIndex.values());
-};
-
-export const getFileCache = async (fileId: number) => {
-  const cacheIndex = fileCacheIndex.get(fileId);
-  if (!cacheIndex) return null;
-
-  cacheIndex.lastRetrievedAt = new Date();
-  storeFileCacheIndex(cacheIndex); // Intended
-  return await readFile(`/cache/${fileId}`);
-};
-
-export const storeFileCache = async (fileId: number, fileBuffer: ArrayBuffer) => {
-  const now = new Date();
-  await writeFile(`/cache/${fileId}`, fileBuffer);
-
-  const cacheIndex: FileCacheIndex = {
-    fileId,
-    cachedAt: now,
-    lastRetrievedAt: now,
-    size: fileBuffer.byteLength,
-  };
-  fileCacheIndex.set(fileId, cacheIndex);
-  await storeFileCacheIndex(cacheIndex);
-};
-
-export const deleteFileCache = async (fileId: number) => {
-  if (!fileCacheIndex.has(fileId)) return;
-
-  fileCacheIndex.delete(fileId);
-  await deleteFile(`/cache/${fileId}`);
-  await deleteFileCacheIndex(fileId);
-};

src/lib/modules/file/download.svelte.ts

@@ -1,110 +0,0 @@
-import axios from "axios";
-import { limitFunction } from "p-limit";
-import { ENCRYPTED_CHUNK_SIZE } from "$lib/constants";
-import { decryptChunk, concatenateBuffers } from "$lib/modules/crypto";
-
-export interface FileDownloadState {
-  id: number;
-  status:
-    | "download-pending"
-    | "downloading"
-    | "decryption-pending"
-    | "decrypting"
-    | "decrypted"
-    | "canceled"
-    | "error";
-  progress?: number;
-  rate?: number;
-  estimated?: number;
-  result?: ArrayBuffer;
-}
-
-type LiveFileDownloadState = FileDownloadState & {
-  status: "download-pending" | "downloading" | "decryption-pending" | "decrypting";
-};
-
-let downloadingFiles: FileDownloadState[] = $state([]);
-
-export const isFileDownloading = (
-  status: FileDownloadState["status"],
-): status is LiveFileDownloadState["status"] =>
-  ["download-pending", "downloading", "decryption-pending", "decrypting"].includes(status);
-
-export const getFileDownloadState = (fileId: number) => {
-  return downloadingFiles.find((file) => file.id === fileId && isFileDownloading(file.status));
-};
-
-export const getDownloadingFiles = () => {
-  return downloadingFiles.filter((file) => isFileDownloading(file.status));
-};
-
-export const clearDownloadedFiles = () => {
-  downloadingFiles = downloadingFiles.filter((file) => isFileDownloading(file.status));
-};
-
-const requestFileDownload = limitFunction(
-  async (state: FileDownloadState, id: number) => {
-    state.status = "downloading";
-
-    const res = await axios.get(`/api/file/${id}/download`, {
-      responseType: "arraybuffer",
-      onDownloadProgress: ({ progress, rate, estimated }) => {
-        state.progress = progress;
-        state.rate = rate;
-        state.estimated = estimated;
-      },
-    });
-    const fileEncrypted: ArrayBuffer = res.data;
-
-    state.status = "decryption-pending";
-    return fileEncrypted;
-  },
-  { concurrency: 1 },
-);
-
-const decryptFile = limitFunction(
-  async (
-    state: FileDownloadState,
-    fileEncrypted: ArrayBuffer,
-    encryptedChunkSize: number,
-    dataKey: CryptoKey,
-  ) => {
-    state.status = "decrypting";
-
-    const chunks: ArrayBuffer[] = [];
-    let offset = 0;
-
-    while (offset < fileEncrypted.byteLength) {
-      const nextOffset = Math.min(offset + encryptedChunkSize, fileEncrypted.byteLength);
-      chunks.push(await decryptChunk(fileEncrypted.slice(offset, nextOffset), dataKey));
-      offset = nextOffset;
-    }
-
-    const fileBuffer = concatenateBuffers(...chunks).buffer;
-    state.status = "decrypted";
-    state.result = fileBuffer;
-    return fileBuffer;
-  },
-  { concurrency: 4 },
-);
-
-export const downloadFile = async (id: number, dataKey: CryptoKey, isLegacy: boolean) => {
-  downloadingFiles.push({
-    id,
-    status: "download-pending",
-  });
-  const state = downloadingFiles.at(-1)!;
-
-  try {
-    const fileEncrypted = await requestFileDownload(state, id);
-    return await decryptFile(
-      state,
-      fileEncrypted,
-      isLegacy ? fileEncrypted.byteLength : ENCRYPTED_CHUNK_SIZE,
-      dataKey,
-    );
-  } catch (e) {
-    state.status = "error";
-    throw e;
-  }
-};

src/lib/modules/file/index.ts

@@ -1,4 +0,0 @@
-export * from "./cache";
-export * from "./download.svelte";
-export * from "./thumbnail";
-export * from "./upload.svelte";

src/lib/modules/file/thumbnail.ts

@@ -1,77 +0,0 @@
-import { LRUCache } from "lru-cache";
-import { writable, type Writable } from "svelte/store";
-import { browser } from "$app/environment";
-import { decryptChunk } from "$lib/modules/crypto";
-import type { SummarizedFileInfo } from "$lib/modules/filesystem";
-import { readFile, writeFile, deleteFile, deleteDirectory } from "$lib/modules/opfs";
-import { getThumbnailUrl } from "$lib/modules/thumbnail";
-
-const loadedThumbnails = new LRUCache<number, Writable<string>>({ max: 100 });
-const loadingThumbnails = new Map<number, Writable<string | undefined>>();
-
-const fetchFromOpfs = async (fileId: number) => {
-  const thumbnailBuffer = await readFile(`/thumbnail/file/${fileId}`);
-  if (thumbnailBuffer) {
-    return getThumbnailUrl(thumbnailBuffer);
-  }
-};
-
-const fetchFromServer = async (fileId: number, dataKey: CryptoKey) => {
-  const res = await fetch(`/api/file/${fileId}/thumbnail/download`);
-  if (!res.ok) return null;
-
-  const thumbnailBuffer = await decryptChunk(await res.arrayBuffer(), dataKey);
-
-  void writeFile(`/thumbnail/file/${fileId}`, thumbnailBuffer);
-  return getThumbnailUrl(thumbnailBuffer);
-};
-
-export const getFileThumbnail = (file: SummarizedFileInfo) => {
-  if (
-    !browser ||
-    !(file.contentType.startsWith("image/") || file.contentType.startsWith("video/"))
-  ) {
-    return undefined;
-  }
-
-  const thumbnail = loadedThumbnails.get(file.id);
-  if (thumbnail) return thumbnail;
-
-  let loadingThumbnail = loadingThumbnails.get(file.id);
-  if (loadingThumbnail) return loadingThumbnail;
-
-  loadingThumbnail = writable(undefined);
-  loadingThumbnails.set(file.id, loadingThumbnail);
-
-  fetchFromOpfs(file.id)
-    .then((thumbnail) => thumbnail ?? (file.dataKey && fetchFromServer(file.id, file.dataKey.key)))
-    .then((thumbnail) => {
-      if (thumbnail) {
-        loadingThumbnail.set(thumbnail);
-        loadedThumbnails.set(file.id, loadingThumbnail as Writable<string>);
-      }
-      loadingThumbnails.delete(file.id);
-    });
-  return loadingThumbnail;
-};
-
-export const storeFileThumbnailCache = async (fileId: number, thumbnailBuffer: ArrayBuffer) => {
-  await writeFile(`/thumbnail/file/${fileId}`, thumbnailBuffer);
-
-  const oldThumbnail = loadedThumbnails.get(fileId);
-  if (oldThumbnail) {
-    oldThumbnail.set(getThumbnailUrl(thumbnailBuffer));
-  } else {
-    loadedThumbnails.set(fileId, writable(getThumbnailUrl(thumbnailBuffer)));
-  }
-};
-
-export const deleteFileThumbnailCache = async (fileId: number) => {
-  loadedThumbnails.delete(fileId);
-  await deleteFile(`/thumbnail/file/${fileId}`);
-};
-
-export const deleteAllFileThumbnailCaches = async () => {
-  loadedThumbnails.clear();
-  await deleteDirectory(`/thumbnail/file`);
-};

src/lib/modules/filesystem/category.ts

@@ -1,123 +0,0 @@
-import * as IndexedDB from "$lib/indexedDB";
-import { trpc, isTRPCClientError } from "$trpc/client";
-import { FilesystemCache, decryptFileMetadata, decryptCategoryMetadata } from "./internal.svelte";
-import type { CategoryInfo, MaybeCategoryInfo } from "./types";
-
-const cache = new FilesystemCache<CategoryId, MaybeCategoryInfo>({
-  async fetchFromIndexedDB(id) {
-    const [category, subCategories] = await Promise.all([
-      id !== "root" ? IndexedDB.getCategoryInfo(id) : undefined,
-      IndexedDB.getCategoryInfos(id),
-    ]);
-    const files = category?.files
-      ? await Promise.all(
-          category.files.map(async (file) => {
-            const fileInfo = await IndexedDB.getFileInfo(file.id);
-            return fileInfo
-              ? {
-                  id: file.id,
-                  parentId: fileInfo.parentId,
-                  contentType: fileInfo.contentType,
-                  name: fileInfo.name,
-                  createdAt: fileInfo.createdAt,
-                  lastModifiedAt: fileInfo.lastModifiedAt,
-                  isFavorite: fileInfo.isFavorite,
-                  isRecursive: file.isRecursive,
-                }
-              : undefined;
-          }),
-        )
-      : undefined;
-
-    if (id === "root") {
-      return {
-        id,
-        exists: true,
-        subCategories,
-      };
-    } else if (category) {
-      return {
-        id,
-        exists: true,
-        parentId: category.parentId,
-        name: category.name,
-        subCategories,
-        files: files?.filter((file) => !!file) ?? [],
-        isFileRecursive: category.isFileRecursive ?? false,
-      };
-    }
-  },
-
-  async fetchFromServer(id, cachedInfo, masterKey) {
-    try {
-      const category = await trpc().category.get.query({ id, recurse: true });
-      const [subCategories, files, metadata] = await Promise.all([
-        Promise.all(
-          category.subCategories.map(async (category) => ({
-            id: category.id,
-            parentId: id,
-            ...(await decryptCategoryMetadata(category, masterKey)),
-          })),
-        ),
-        category.files &&
-          Promise.all(
-            category.files.map(async (file) => ({
-              id: file.id,
-              parentId: file.parent,
-              contentType: file.contentType,
-              isFavorite: file.isFavorite,
-              isRecursive: file.isRecursive,
-              ...(await decryptFileMetadata(file, masterKey)),
-            })),
-          ),
-        category.metadata && decryptCategoryMetadata(category.metadata, masterKey),
-      ]);
-
-      return storeToIndexedDB(
-        id !== "root"
-          ? {
-              id,
-              parentId: category.metadata!.parent,
-              subCategories,
-              files: files!,
-              isFileRecursive: cachedInfo?.isFileRecursive ?? false,
-              ...metadata!,
-            }
-          : { id, subCategories },
-      );
-    } catch (e) {
-      if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
-        await IndexedDB.deleteCategoryInfo(id as number);
-        return { id, exists: false };
-      }
-      throw e;
-    }
-  },
-});
-
-const storeToIndexedDB = (info: CategoryInfo) => {
-  if (info.id !== "root") {
-    void IndexedDB.storeCategoryInfo(info);
-
-    // TODO: Bulk Upsert
-    new Map(info.files.map((file) => [file.id, file])).forEach((file) => {
-      void IndexedDB.storeFileInfo(file);
-    });
-  }
-
-  // TODO: Bulk Upsert
-  info.subCategories.forEach((category) => {
-    void IndexedDB.storeCategoryInfo(category);
-  });
-
-  void IndexedDB.deleteDanglingCategoryInfos(
-    info.id,
-    new Set(info.subCategories.map(({ id }) => id)),
-  );
-
-  return { ...info, exists: true as const };
-};
-
-export const getCategoryInfo = (id: CategoryId, masterKey: CryptoKey) => {
-  return cache.get(id, masterKey);
-};

src/lib/modules/filesystem/directory.ts

@@ -1,134 +0,0 @@
-import * as IndexedDB from "$lib/indexedDB";
-import { trpc, isTRPCClientError } from "$trpc/client";
-import { FilesystemCache, decryptDirectoryMetadata, decryptFileMetadata } from "./internal.svelte";
-import type { DirectoryInfo, MaybeDirectoryInfo } from "./types";
-
-const cache = new FilesystemCache<DirectoryId, MaybeDirectoryInfo>({
-  async fetchFromIndexedDB(id) {
-    const [directory, subDirectories, files] = await Promise.all([
-      id !== "root" ? IndexedDB.getDirectoryInfo(id) : undefined,
-      IndexedDB.getDirectoryInfos(id),
-      IndexedDB.getFileInfos(id),
-    ]);
-
-    if (id === "root") {
-      return {
-        id,
-        exists: true,
-        subDirectories,
-        files,
-      };
-    } else if (directory) {
-      return {
-        id,
-        exists: true,
-        parentId: directory.parentId,
-        name: directory.name,
-        subDirectories,
-        files,
-        isFavorite: directory.isFavorite,
-      };
-    }
-  },
-
-  async fetchFromServer(id, _cachedInfo, masterKey) {
-    try {
-      const directory = await trpc().directory.get.query({ id });
-      const [subDirectories, files, metadata] = await Promise.all([
-        Promise.all(
-          directory.subDirectories.map(async (directory) => ({
-            id: directory.id,
-            parentId: id,
-            isFavorite: directory.isFavorite,
-            ...(await decryptDirectoryMetadata(directory, masterKey)),
-          })),
-        ),
-        Promise.all(
-          directory.files.map(async (file) => ({
-            id: file.id,
-            parentId: id,
-            contentType: file.contentType,
-            isFavorite: file.isFavorite,
-            ...(await decryptFileMetadata(file, masterKey)),
-          })),
-        ),
-        directory.metadata && decryptDirectoryMetadata(directory.metadata, masterKey),
-      ]);
-
-      return storeToIndexedDB(
-        id !== "root"
-          ? {
-              id,
-              parentId: directory.metadata!.parent,
-              subDirectories,
-              files,
-              isFavorite: directory.metadata!.isFavorite,
-              ...metadata!,
-            }
-          : { id, subDirectories, files },
-      );
-    } catch (e) {
-      if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
-        await IndexedDB.deleteDirectoryInfo(id as number);
-        return { id, exists: false as const };
-      }
-      throw e;
-    }
-  },
-});
-
-const storeToIndexedDB = (info: DirectoryInfo) => {
-  if (info.id !== "root") {
-    void IndexedDB.storeDirectoryInfo(info);
-  }
-
-  // TODO: Bulk Upsert
-  info.subDirectories.forEach((subDirectory) => {
-    void IndexedDB.storeDirectoryInfo(subDirectory);
-  });
-
-  // TODO: Bulk Upsert
-  info.files.forEach((file) => {
-    void IndexedDB.storeFileInfo(file);
-  });
-
-  void IndexedDB.deleteDanglingDirectoryInfos(
-    info.id,
-    new Set(info.subDirectories.map(({ id }) => id)),
-  );
-  void IndexedDB.deleteDanglingFileInfos(info.id, new Set(info.files.map(({ id }) => id)));
-
-  return { ...info, exists: true as const };
-};
-
-export const getDirectoryInfo = (
-  id: DirectoryId,
-  masterKey: CryptoKey,
-  options?: {
-    serverResponse?: {
-      parent: DirectoryId;
-      dek: string;
-      dekVersion: Date;
-      name: string;
-      nameIv: string;
-      isFavorite: boolean;
-    };
-  },
-) => {
-  return cache.get(id, masterKey, {
-    fetchFromServer:
-      options?.serverResponse &&
-      (async (cachedValue) => {
-        const metadata = await decryptDirectoryMetadata(options!.serverResponse!, masterKey);
-        return storeToIndexedDB({
-          subDirectories: [],
-          files: [],
-          ...cachedValue,
-          id: id as number,
-          parentId: options!.serverResponse!.parent,
-          isFavorite: options!.serverResponse!.isFavorite,
-          ...metadata,
-        });
-      }),
-  });
-};

src/lib/modules/filesystem/file.ts

@@ -1,213 +0,0 @@
-import * as IndexedDB from "$lib/indexedDB";
-import { trpc, isTRPCClientError } from "$trpc/client";
-import { FilesystemCache, decryptFileMetadata, decryptCategoryMetadata } from "./internal.svelte";
-import type { FileInfo, MaybeFileInfo } from "./types";
-
-const cache = new FilesystemCache<number, MaybeFileInfo>({
-  async fetchFromIndexedDB(id) {
-    const file = await IndexedDB.getFileInfo(id);
-    const categories = file?.categoryIds
-      ? await Promise.all(
-          file.categoryIds.map(async (categoryId) => {
-            const category = await IndexedDB.getCategoryInfo(categoryId);
-            return category
-              ? { id: category.id, parentId: category.parentId, name: category.name }
-              : undefined;
-          }),
-        )
-      : undefined;
-
-    if (file) {
-      return {
-        id,
-        exists: true,
-        parentId: file.parentId,
-        contentType: file.contentType,
-        name: file.name,
-        createdAt: file.createdAt,
-        lastModifiedAt: file.lastModifiedAt,
-        categories: categories?.filter((category) => !!category) ?? [],
-        isFavorite: file.isFavorite,
-      };
-    }
-  },
-
-  async fetchFromServer(id, _cachedInfo, masterKey) {
-    try {
-      const file = await trpc().file.get.query({ id });
-      const [categories, metadata] = await Promise.all([
-        Promise.all(
-          file.categories.map(async (category) => ({
-            id: category.id,
-            parentId: category.parent,
-            ...(await decryptCategoryMetadata(category, masterKey)),
-          })),
-        ),
-        decryptFileMetadata(file, masterKey),
-      ]);
-
-      return storeToIndexedDB({
-        id,
-        isLegacy: file.isLegacy,
-        parentId: file.parent,
-        dataKey: metadata.dataKey,
-        contentType: file.contentType,
-        name: metadata.name,
-        createdAt: metadata.createdAt,
-        lastModifiedAt: metadata.lastModifiedAt,
-        categories,
-        isFavorite: file.isFavorite,
-      });
-    } catch (e) {
-      if (isTRPCClientError(e) && e.data?.code === "NOT_FOUND") {
-        await IndexedDB.deleteFileInfo(id);
-        return { id, exists: false as const };
-      }
-      throw e;
-    }
-  },
-
-  async bulkFetchFromIndexedDB(ids) {
-    const files = await IndexedDB.bulkGetFileInfos([...ids]);
-    const categories = await Promise.all(
-      files.map(async (file) =>
-        file?.categoryIds
-          ? await Promise.all(
-              file.categoryIds.map(async (categoryId) => {
-                const category = await IndexedDB.getCategoryInfo(categoryId);
-                return category
-                  ? { id: category.id, parentId: category.parentId, name: category.name }
-                  : undefined;
-              }),
-            )
-          : undefined,
-      ),
-    );
-
-    return new Map(
-      files
-        .filter((file) => !!file)
-        .map((file, index) => [
-          file.id,
-          {
-            ...file,
-            exists: true,
-            categories: categories[index]?.filter((category) => !!category) ?? [],
-          },
-        ]),
-    );
-  },
-
-  async bulkFetchFromServer(ids, masterKey) {
-    const idsArray = [...ids.keys()];
-
-    const filesRaw = await trpc().file.bulkGet.query({ ids: idsArray });
-    const files = await Promise.all(
-      filesRaw.map(async ({ id, categories: categoriesRaw, ...metadataRaw }) => {
-        const [categories, metadata] = await Promise.all([
-          Promise.all(
-            categoriesRaw.map(async (category) => ({
-              id: category.id,
-              parentId: category.parent,
-              ...(await decryptCategoryMetadata(category, masterKey)),
-            })),
-          ),
-          decryptFileMetadata(metadataRaw, masterKey),
-        ]);
-
-        return {
-          id,
-          exists: true as const,
-          isLegacy: metadataRaw.isLegacy,
-          parentId: metadataRaw.parent,
-          contentType: metadataRaw.contentType,
-          categories,
-          isFavorite: metadataRaw.isFavorite,
-          ...metadata,
-        };
-      }),
-    );
-
-    const existingIds = new Set(filesRaw.map(({ id }) => id));
-    const deletedIds = idsArray.filter((id) => !existingIds.has(id));
-
-    void IndexedDB.bulkDeleteFileInfos(deletedIds);
-    return new Map<number, MaybeFileInfo>([
-      ...bulkStoreToIndexedDB(files),
-      ...deletedIds.map((id) => [id, { id, exists: false }] as const),
-    ]);
-  },
-});
-
-const storeToIndexedDB = (info: FileInfo) => {
-  void IndexedDB.storeFileInfo({
-    ...info,
-    categoryIds: info.categories.map(({ id }) => id),
-  });
-
-  info.categories.forEach((category) => {
-    void IndexedDB.storeCategoryInfo(category);
-  });
-
-  return { ...info, exists: true as const };
-};
-
-const bulkStoreToIndexedDB = (infos: FileInfo[]) => {
-  // TODO: Bulk Upsert
-  infos.forEach((info) => {
-    void IndexedDB.storeFileInfo({
-      ...info,
-      categoryIds: info.categories.map(({ id }) => id),
-    });
-  });
-
-  // TODO: Bulk Upsert
-  new Map(
-    infos.flatMap(({ categories }) => categories).map((category) => [category.id, category]),
-  ).forEach((category) => {
-    void IndexedDB.storeCategoryInfo(category);
-  });
-
-  return infos.map((info) => [info.id, { ...info, exists: true }] as const);
-};
-
-export const getFileInfo = (
-  id: number,
-  masterKey: CryptoKey,
-  options?: {
-    serverResponse?: {
-      parent: DirectoryId;
-      dek: string;
-      dekVersion: Date;
-      contentType: string;
-      name: string;
-      nameIv: string;
-      createdAt?: string;
-      createdAtIv?: string;
-      lastModifiedAt: string;
-      lastModifiedAtIv: string;
-      isFavorite: boolean;
-    };
-  },
-) => {
-  return cache.get(id, masterKey, {
-    fetchFromServer:
-      options?.serverResponse &&
-      (async (cachedValue) => {
-        const metadata = await decryptFileMetadata(options!.serverResponse!, masterKey);
-        return storeToIndexedDB({
-          categories: [],
-          ...cachedValue,
-          id,
-          parentId: options!.serverResponse!.parent,
-          contentType: options!.serverResponse!.contentType,
-          isFavorite: options!.serverResponse!.isFavorite,
-          ...metadata,
-        });
-      }),
-  });
-};
-
-export const bulkGetFileInfo = (ids: number[], masterKey: CryptoKey) => {
-  return cache.bulkGet(new Set(ids), masterKey);
-};

src/lib/modules/filesystem/index.ts

@@ -1,4 +0,0 @@
-export * from "./category";
-export * from "./directory";
-export * from "./file";
-export * from "./types";

src/lib/modules/filesystem/internal.svelte.ts

@@ -1,180 +0,0 @@
-import { untrack } from "svelte";
-import { unwrapDataKey, decryptString } from "$lib/modules/crypto";
-
-interface FilesystemCacheOptions<K, V> {
-  fetchFromIndexedDB: (key: K) => Promise<V | undefined>;
-  fetchFromServer: (key: K, cachedValue: V | undefined, masterKey: CryptoKey) => Promise<V>;
-  bulkFetchFromIndexedDB?: (keys: Set<K>) => Promise<Map<K, V>>;
-  bulkFetchFromServer?: (
-    keys: Map<K, { cachedValue: V | undefined }>,
-    masterKey: CryptoKey,
-  ) => Promise<Map<K, V>>;
-}
-
-export class FilesystemCache<K, V extends object> {
-  private map = new Map<K, { value?: V; promise?: Promise<V> }>();
-
-  constructor(private readonly options: FilesystemCacheOptions<K, V>) {}
-
-  get(
-    key: K,
-    masterKey: CryptoKey,
-    options?: { fetchFromServer?: (cachedValue: V | undefined) => Promise<V> },
-  ) {
-    return untrack(() => {
-      let state = this.map.get(key);
-      if (state?.promise) return state.value ?? state.promise;
-
-      const { promise: newPromise, resolve } = Promise.withResolvers<V>();
-
-      if (!state) {
-        const newState = $state({});
-        state = newState;
-        this.map.set(key, newState);
-      }
-
-      (state.value
-        ? Promise.resolve($state.snapshot(state.value) as V)
-        : this.options.fetchFromIndexedDB(key).then((loadedInfo) => {
-            if (loadedInfo) {
-              state.value = loadedInfo;
-              resolve(state.value);
-            }
-            return loadedInfo;
-          })
-      )
-        .then(
-          (cachedInfo) =>
-            options?.fetchFromServer?.(cachedInfo) ??
-            this.options.fetchFromServer(key, cachedInfo, masterKey),
-        )
-        .then((loadedInfo) => {
-          if (state.value) {
-            Object.assign(state.value, loadedInfo);
-          } else {
-            state.value = loadedInfo;
-          }
-          resolve(state.value);
-        })
-        .finally(() => {
-          state.promise = undefined;
-        });
-
-      state.promise = newPromise;
-      return state.value ?? newPromise;
-    });
-  }
-
-  bulkGet(keys: Set<K>, masterKey: CryptoKey) {
-    return untrack(() => {
-      const newPromises = new Map(
-        keys
-          .keys()
-          .filter((key) => this.map.get(key)?.promise === undefined)
-          .map((key) => [key, Promise.withResolvers<V>()]),
-      );
-      newPromises.forEach(({ promise }, key) => {
-        const state = this.map.get(key);
-        if (state) {
-          state.promise = promise;
-        } else {
-          const newState = $state({ promise });
-          this.map.set(key, newState);
-        }
-      });
-
-      const resolve = (loadedInfos: Map<K, V>) => {
-        loadedInfos.forEach((loadedInfo, key) => {
-          const state = this.map.get(key)!;
-          if (state.value) {
-            Object.assign(state.value, loadedInfo);
-          } else {
-            state.value = loadedInfo;
-          }
-          newPromises.get(key)!.resolve(state.value);
-        });
-        return loadedInfos;
-      };
-
-      this.options.bulkFetchFromIndexedDB!(
-        new Set(newPromises.keys().filter((key) => this.map.get(key)!.value === undefined)),
-      )
-        .then(resolve)
-        .then(() =>
-          this.options.bulkFetchFromServer!(
-            new Map(
-              newPromises.keys().map((key) => [key, { cachedValue: this.map.get(key)!.value }]),
-            ),
-            masterKey,
-          ),
-        )
-        .then(resolve)
-        .finally(() => {
-          newPromises.forEach((_, key) => {
-            this.map.get(key)!.promise = undefined;
-          });
-        });
-
-      const bottleneckPromises = Array.from(
-        keys
-          .keys()
-          .filter((key) => this.map.get(key)!.value === undefined)
-          .map((key) => this.map.get(key)!.promise!),
-      );
-      const makeResult = () =>
-        new Map(keys.keys().map((key) => [key, this.map.get(key)!.value!] as const));
-      return bottleneckPromises.length > 0
-        ? Promise.all(bottleneckPromises).then(makeResult)
-        : makeResult();
-    });
-  }
-}
-
-export const decryptDirectoryMetadata = async (
-  metadata: { dek: string; dekVersion: Date; name: string; nameIv: string },
-  masterKey: CryptoKey,
-) => {
-  const { dataKey } = await unwrapDataKey(metadata.dek, masterKey);
-  const name = await decryptString(metadata.name, metadata.nameIv, dataKey);
-
-  return {
-    dataKey: { key: dataKey, version: metadata.dekVersion },
-    name,
-  };
-};
-
-const decryptDate = async (ciphertext: string, iv: string, dataKey: CryptoKey) => {
-  return new Date(parseInt(await decryptString(ciphertext, iv, dataKey), 10));
-};
-
-export const decryptFileMetadata = async (
-  metadata: {
-    dek: string;
-    dekVersion: Date;
-    name: string;
-    nameIv: string;
-    createdAt?: string;
-    createdAtIv?: string;
-    lastModifiedAt: string;
-    lastModifiedAtIv: string;
-  },
-  masterKey: CryptoKey,
-) => {
-  const { dataKey } = await unwrapDataKey(metadata.dek, masterKey);
-  const [name, createdAt, lastModifiedAt] = await Promise.all([
-    decryptString(metadata.name, metadata.nameIv, dataKey),
-    metadata.createdAt
-      ? decryptDate(metadata.createdAt, metadata.createdAtIv!, dataKey)
-      : undefined,
-    decryptDate(metadata.lastModifiedAt, metadata.lastModifiedAtIv, dataKey),
-  ]);
-
-  return {
-    dataKey: { key: dataKey, version: metadata.dekVersion },
-    name,
-    createdAt,
-    lastModifiedAt,
-  };
-};
-
-export const decryptCategoryMetadata = decryptDirectoryMetadata;

src/lib/modules/http.ts

@@ -1,22 +0,0 @@
-export const parseRangeHeader = (value: string | null) => {
-  if (!value) return undefined;
-
-  const firstRange = value.split(",")[0]!.trim();
-  const parts = firstRange.replace(/bytes=/, "").split("-");
-  return {
-    start: parts[0] ? parseInt(parts[0], 10) : undefined,
-    end: parts[1] ? parseInt(parts[1], 10) : undefined,
-  };
-};
-
-export const getContentRangeHeader = (range?: { start: number; end: number; total: number }) => {
-  return range && { "Content-Range": `bytes ${range.start}-${range.end}/${range.total}` };
-};
-
-export const parseContentDigestHeader = (value: string | null) => {
-  if (!value) return undefined;
-
-  const firstDigest = value.split(",")[0]!.trim();
-  const match = firstDigest.match(/^sha-256=:([A-Za-z0-9+/=]+):$/);
-  return match?.[1];
-};

src/lib/modules/upload.ts

@@ -1,183 +0,0 @@
-import axios from "axios";
-import pLimit from "p-limit";
-import { ENCRYPTION_OVERHEAD, CHUNK_SIZE } from "$lib/constants";
-import { encryptChunk, digestMessage, encodeToBase64 } from "$lib/modules/crypto";
-import { BoundedQueue } from "$lib/utils";
-
-interface UploadStats {
-  progress: number;
-  rate: number;
-}
-
-interface EncryptedChunk {
-  index: number;
-  data: ArrayBuffer;
-  hash: string;
-}
-
-const createSpeedMeter = (timeWindow = 3000, minInterval = 200, warmupPeriod = 500) => {
-  const samples: { t: number; b: number }[] = [];
-  let lastSpeed = 0;
-  let startTime: number | null = null;
-
-  return (bytesNow?: number) => {
-    if (bytesNow === undefined) return lastSpeed;
-
-    const now = performance.now();
-
-    // Initialize start time on first call
-    if (startTime === null) {
-      startTime = now;
-    }
-
-    // Check if enough time has passed since the last sample
-    const lastSample = samples[samples.length - 1];
-    if (lastSample && now - lastSample.t < minInterval) {
-      return lastSpeed;
-    }
-
-    samples.push({ t: now, b: bytesNow });
-
-    // Remove old samples outside the time window
-    const cutoff = now - timeWindow;
-    while (samples.length > 2 && samples[0]!.t < cutoff) samples.shift();
-
-    // Need at least 2 samples to calculate speed
-    if (samples.length < 2) {
-      return lastSpeed;
-    }
-
-    const first = samples[0]!;
-    const dt = now - first.t;
-    const db = bytesNow - first.b;
-
-    if (dt >= minInterval) {
-      const instantSpeed = (db / dt) * 1000;
-      // Apply EMA for smoother speed transitions
-      const alpha = 0.3;
-      const rawSpeed =
-        lastSpeed === 0 ? instantSpeed : alpha * instantSpeed + (1 - alpha) * lastSpeed;
-
-      // Apply warmup ramp to prevent initial overestimation
-      const elapsed = now - startTime;
-      const warmupWeight = Math.min(1, elapsed / warmupPeriod);
-      lastSpeed = rawSpeed * warmupWeight;
-    }
-
-    return lastSpeed;
-  };
-};
-
-const encryptChunkData = async (
-  chunk: Blob,
-  dataKey: CryptoKey,
-): Promise<{ data: ArrayBuffer; hash: string }> => {
-  const encrypted = await encryptChunk(await chunk.arrayBuffer(), dataKey);
-  const hash = encodeToBase64(await digestMessage(encrypted));
-  return { data: encrypted, hash };
-};
-
-const uploadEncryptedChunk = async (
-  uploadId: string,
-  chunkIndex: number,
-  encrypted: ArrayBuffer,
-  hash: string,
-  onChunkProgress: (chunkIndex: number, loaded: number) => void,
-) => {
-  await axios.post(`/api/upload/${uploadId}/chunks/${chunkIndex + 1}`, encrypted, {
-    headers: {
-      "Content-Type": "application/octet-stream",
-      "Content-Digest": `sha-256=:${hash}:`,
-    },
-    onUploadProgress(e) {
-      onChunkProgress(chunkIndex, e.loaded ?? 0);
-    },
-  });
-
-  onChunkProgress(chunkIndex, encrypted.byteLength);
-};
-
-export const uploadBlob = async (
-  uploadId: string,
-  blob: Blob,
-  dataKey: CryptoKey,
-  options?: { concurrency?: number; onProgress?: (s: UploadStats) => void },
-) => {
-  const onProgress = options?.onProgress;
-  const networkConcurrency = options?.concurrency ?? 4;
-  const maxQueueSize = 8;
-
-  const totalChunks = Math.ceil(blob.size / CHUNK_SIZE);
-  const totalBytes = blob.size + totalChunks * ENCRYPTION_OVERHEAD;
-
-  const uploadedByChunk = new Array<number>(totalChunks).fill(0);
-  const speedMeter = createSpeedMeter(3000, 200);
-
-  const emit = () => {
-    if (!onProgress) return;
-
-    const uploadedBytes = uploadedByChunk.reduce((a, b) => a + b, 0);
-    const rate = speedMeter(uploadedBytes);
-    const progress = Math.min(1, uploadedBytes / totalBytes);
-
-    onProgress({ progress, rate });
-  };
-
-  const onChunkProgress = (idx: number, loaded: number) => {
-    uploadedByChunk[idx] = loaded;
-    emit();
-  };
-
-  const queue = new BoundedQueue<EncryptedChunk>(maxQueueSize);
-  let encryptionError: Error | null = null;
-
-  // Producer: encrypt chunks and push to queue
-  const encryptionProducer = async () => {
-    try {
-      for (let i = 0; i < totalChunks; i++) {
-        const chunk = blob.slice(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE);
-        const { data, hash } = await encryptChunkData(chunk, dataKey);
-        await queue.push({ index: i, data, hash });
-      }
-    } catch (e) {
-      encryptionError = e instanceof Error ? e : new Error(String(e));
-    } finally {
-      queue.close();
-    }
-  };
-
-  // Consumer: upload chunks from queue with concurrency limit
-  const uploadConsumer = async () => {
-    const limit = pLimit(networkConcurrency);
-    const activeTasks = new Set<Promise<void>>();
-
-    while (true) {
-      const item = await queue.pop();
-      if (item === null) break;
-      if (encryptionError) throw encryptionError;
-
-      const task = limit(async () => {
-        try {
-          await uploadEncryptedChunk(uploadId, item.index, item.data, item.hash, onChunkProgress);
-        } finally {
-          // @ts-ignore
-          item.data = null;
-        }
-      });
-
-      activeTasks.add(task);
-      task.finally(() => activeTasks.delete(task));
-
-      if (activeTasks.size >= networkConcurrency) {
-        await Promise.race(activeTasks);
-      }
-    }
-
-    await Promise.all(activeTasks);
-  };
-
-  // Run producer and consumer concurrently
-  await Promise.all([encryptionProducer(), uploadConsumer()]);
-
-  onProgress?.({ progress: 1, rate: speedMeter() });
-};

src/lib/schemas/filesystem.ts

@@ -1,4 +0,0 @@
-import { z } from "zod";
-
-export const DirectoryIdSchema = z.union([z.literal("root"), z.int().positive()]);
-export const CategoryIdSchema = z.union([z.literal("root"), z.int().positive()]);

src/lib/schemas/index.ts

@@ -1 +0,0 @@
-export * from "./filesystem";

src/lib/server/auth.ts

@@ -0,0 +1,112 @@
+import { ClientRepo, SessionRepo, db } from "#lib/server/db/index.ts";
+import env from "#lib/server/config.ts";
+import { verifySessionId } from "#lib/server/crypto.ts";
+import { AppError, invalidSessionError } from "#lib/server/errors.ts";
+
+export interface Session {
+  sessionId: string;
+  userId: number;
+  clientId?: number;
+}
+
+export interface ClientSession extends Session {
+  clientId: number;
+}
+
+export type SessionPermission =
+  "any" | "notClient" | "anyClient" | "pendingClient" | "activeClient";
+
+export class AuthenticationError extends Error {
+  constructor(
+    public status: 400 | 401,
+    message: string,
+  ) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+}
+
+export const cookieOptions = {
+  path: "/",
+  maxAge: env.session.exp / 1000,
+  secure: true,
+  sameSite: "strict",
+} as const;
+
+export const authenticate = async (sessionIdSigned: string, ip: string, userAgent: string) => {
+  const sessionId = verifySessionId(sessionIdSigned, env.session.secret);
+  if (!sessionId) {
+    throw new AuthenticationError(400, "Invalid session id");
+  }
+
+  const session = await SessionRepo.refreshSession(db, sessionId, ip, userAgent);
+  if (!session) {
+    throw new AuthenticationError(401, "Invalid session id");
+  }
+  return {
+    id: sessionId,
+    userId: session.userId,
+    clientId: session.clientId ?? undefined,
+  };
+};
+
+const ensureUserClientState = async (
+  userId: number,
+  clientId: number | undefined,
+  state: "pending" | "active",
+) => {
+  if (!clientId) {
+    throw new AppError("FORBIDDEN", "Forbidden");
+  }
+
+  const userClient = await ClientRepo.getUserClient(db, userId, clientId);
+  if (!userClient) {
+    throw invalidSessionError();
+  } else if (userClient.state !== state) {
+    throw new AppError("FORBIDDEN", "Forbidden");
+  }
+};
+
+export async function authorize(
+  locals: App.Locals,
+  requiredPermission: "any" | "notClient",
+): Promise<Session>;
+
+export async function authorize(
+  locals: App.Locals,
+  requiredPermission: "anyClient" | "pendingClient" | "activeClient",
+): Promise<ClientSession>;
+
+export async function authorize(
+  locals: App.Locals,
+  requiredPermission: SessionPermission,
+): Promise<Session> {
+  if (!locals.session) {
+    throw new AppError("UNAUTHORIZED", "Unauthenticated");
+  }
+
+  const { id: sessionId, userId, clientId } = locals.session;
+
+  switch (requiredPermission) {
+    case "any":
+      break;
+    case "notClient":
+      if (clientId) {
+        throw new AppError("FORBIDDEN", "Forbidden");
+      }
+      break;
+    case "anyClient":
+      if (!clientId) {
+        throw new AppError("FORBIDDEN", "Forbidden");
+      }
+      break;
+    case "pendingClient":
+      await ensureUserClientState(userId, clientId, "pending");
+      break;
+    case "activeClient":
+      await ensureUserClientState(userId, clientId, "active");
+      break;
+  }
+
+  return { sessionId, userId, clientId };
+}

src/lib/server/config.ts

@@ -0,0 +1,35 @@
+import {
+  NODE_ENV,
+  DATABASE_HOST,
+  DATABASE_PORT,
+  DATABASE_USER,
+  DATABASE_PASSWORD,
+  DATABASE_NAME,
+  SESSION_SECRET,
+  SESSION_EXPIRES,
+  USER_CLIENT_CHALLENGE_EXPIRES,
+  SESSION_UPGRADE_CHALLENGE_EXPIRES,
+  LIBRARY_PATH,
+  THUMBNAILS_PATH,
+} from "$app/env/private";
+
+export default {
+  nodeEnv: NODE_ENV,
+  database: {
+    host: DATABASE_HOST,
+    port: DATABASE_PORT,
+    user: DATABASE_USER,
+    password: DATABASE_PASSWORD,
+    name: DATABASE_NAME,
+  },
+  session: {
+    secret: SESSION_SECRET,
+    exp: SESSION_EXPIRES,
+  },
+  challenge: {
+    userClientExp: USER_CLIENT_CHALLENGE_EXPIRES,
+    sessionUpgradeExp: SESSION_UPGRADE_CHALLENGE_EXPIRES,
+  },
+  libraryPath: LIBRARY_PATH,
+  thumbnailsPath: THUMBNAILS_PATH,
+};

src/lib/server/crypto.ts

@@ -56,12 +56,13 @@ export const issueSessionId = async (length: number, secret: string) => {
 export const verifySessionId = (sessionIdSigned: string, secret: string) => {
   const [sessionIdHex, sessionIdHmac] = sessionIdSigned.split(".");
   if (!sessionIdHex || !sessionIdHmac) return;
-  if (
+
-    timingSafeEqual(
+  const actualHmac = Buffer.from(sessionIdHmac, "hex");
-      Buffer.from(sessionIdHmac, "hex"),
+  const expectedHmac = createHmac("sha256", secret)
-      createHmac("sha256", secret).update(Buffer.from(sessionIdHex, "hex")).digest(),
+    .update(Buffer.from(sessionIdHex, "hex"))
-    )
+    .digest();
-  ) {
+  // `timingSafeEqual` throws if the lengths differ (e.g. malformed hex)
+  if (actualHmac.length === expectedHmac.length && timingSafeEqual(actualHmac, expectedHmac)) {
     return sessionIdHex;
   }
 };

src/lib/server/db/category.ts

@@ -1,145 +0,0 @@
-import { IntegrityError } from "./error";
-import db from "./kysely";
-import type { Ciphertext } from "./schema";
-
-interface Category {
-  id: number;
-  parentId: CategoryId;
-  userId: number;
-  mekVersion: number;
-  encDek: string;
-  dekVersion: Date;
-  encName: Ciphertext;
-}
-
-export type NewCategory = Omit<Category, "id">;
-
-export const registerCategory = async (params: NewCategory) => {
-  await db.transaction().execute(async (trx) => {
-    const mek = await trx
-      .selectFrom("master_encryption_key")
-      .select("version")
-      .where("user_id", "=", params.userId)
-      .where("state", "=", "active")
-      .limit(1)
-      .forUpdate()
-      .executeTakeFirst();
-    if (mek?.version !== params.mekVersion) {
-      throw new IntegrityError("Inactive MEK version");
-    }
-
-    const { categoryId } = await trx
-      .insertInto("category")
-      .values({
-        parent_id: params.parentId !== "root" ? params.parentId : null,
-        user_id: params.userId,
-        master_encryption_key_version: params.mekVersion,
-        encrypted_data_encryption_key: params.encDek,
-        data_encryption_key_version: params.dekVersion,
-        encrypted_name: params.encName,
-      })
-      .returning("id as categoryId")
-      .executeTakeFirstOrThrow();
-    await trx
-      .insertInto("category_log")
-      .values({
-        category_id: categoryId,
-        timestamp: new Date(),
-        action: "create",
-        new_name: params.encName,
-      })
-      .execute();
-  });
-};
-
-export const getAllCategoriesByParent = async (userId: number, parentId: CategoryId) => {
-  let query = db.selectFrom("category").selectAll().where("user_id", "=", userId);
-  query =
-    parentId === "root"
-      ? query.where("parent_id", "is", null)
-      : query.where("parent_id", "=", parentId);
-  const categories = await query.execute();
-  return categories.map(
-    (category) =>
-      ({
-        id: category.id,
-        parentId: category.parent_id ?? "root",
-        userId: category.user_id,
-        mekVersion: category.master_encryption_key_version,
-        encDek: category.encrypted_data_encryption_key,
-        dekVersion: category.data_encryption_key_version,
-        encName: category.encrypted_name,
-      }) satisfies Category,
-  );
-};
-
-export const getCategory = async (userId: number, categoryId: number) => {
-  const category = await db
-    .selectFrom("category")
-    .selectAll()
-    .where("id", "=", categoryId)
-    .where("user_id", "=", userId)
-    .limit(1)
-    .executeTakeFirst();
-  return category
-    ? ({
-        id: category.id,
-        parentId: category.parent_id ?? "root",
-        userId: category.user_id,
-        mekVersion: category.master_encryption_key_version,
-        encDek: category.encrypted_data_encryption_key,
-        dekVersion: category.data_encryption_key_version,
-        encName: category.encrypted_name,
-      } satisfies Category)
-    : null;
-};
-
-export const setCategoryEncName = async (
-  userId: number,
-  categoryId: number,
-  dekVersion: Date,
-  encName: Ciphertext,
-) => {
-  await db.transaction().execute(async (trx) => {
-    const category = await trx
-      .selectFrom("category")
-      .select("data_encryption_key_version")
-      .where("id", "=", categoryId)
-      .where("user_id", "=", userId)
-      .limit(1)
-      .forUpdate()
-      .executeTakeFirst();
-    if (!category) {
-      throw new IntegrityError("Category not found");
-    } else if (category.data_encryption_key_version.getTime() !== dekVersion.getTime()) {
-      throw new IntegrityError("Invalid DEK version");
-    }
-
-    await trx
-      .updateTable("category")
-      .set({ encrypted_name: encName })
-      .where("id", "=", categoryId)
-      .where("user_id", "=", userId)
-      .execute();
-    await trx
-      .insertInto("category_log")
-      .values({
-        category_id: categoryId,
-        timestamp: new Date(),
-        action: "rename",
-        new_name: encName,
-      })
-      .execute();
-  });
-};
-
-export const unregisterCategory = async (userId: number, categoryId: number) => {
-  const res = await db
-    .deleteFrom("category")
-    .where("id", "=", categoryId)
-    .where("user_id", "=", userId)
-    .executeTakeFirst();
-  if (res.numDeletedRows === 0n) {
-    throw new IntegrityError("Category not found");
-  }
-};

src/lib/server/db/client.ts

@@ -1,197 +0,0 @@
-import pg from "pg";
-import { IntegrityError } from "./error";
-import db from "./kysely";
-import type { UserClientState } from "./schema";
-
-interface Client {
-  id: number;
-  encPubKey: string;
-  sigPubKey: string;
-}
-
-interface UserClient {
-  userId: number;
-  clientId: number;
-  state: UserClientState;
-}
-
-interface UserClientWithDetails extends UserClient {
-  encPubKey: string;
-  sigPubKey: string;
-}
-
-export const createClient = async (encPubKey: string, sigPubKey: string, userId: number) => {
-  return await db
-    .transaction()
-    .setIsolationLevel("serializable")
-    .execute(async (trx) => {
-      const client = await trx
-        .selectFrom("client")
-        .where((eb) =>
-          eb.or([
-            eb("encryption_public_key", "=", encPubKey),
-            eb("encryption_public_key", "=", sigPubKey),
-            eb("signature_public_key", "=", encPubKey),
-            eb("signature_public_key", "=", sigPubKey),
-          ]),
-        )
-        .limit(1)
-        .executeTakeFirst();
-      if (client) {
-        throw new IntegrityError("Public key(s) already registered");
-      }
-
-      const { clientId } = await trx
-        .insertInto("client")
-        .values({ encryption_public_key: encPubKey, signature_public_key: sigPubKey })
-        .returning("id as clientId")
-        .executeTakeFirstOrThrow();
-      await trx
-        .insertInto("user_client")
-        .values({ user_id: userId, client_id: clientId })
-        .execute();
-      return { id: clientId };
-    });
-};
-
-export const getClient = async (clientId: number) => {
-  const client = await db
-    .selectFrom("client")
-    .selectAll()
-    .where("id", "=", clientId)
-    .limit(1)
-    .executeTakeFirst();
-  return client
-    ? ({
-        id: client.id,
-        encPubKey: client.encryption_public_key,
-        sigPubKey: client.signature_public_key,
-      } satisfies Client)
-    : null;
-};
-
-export const getClientByPubKeys = async (encPubKey: string, sigPubKey: string) => {
-  const client = await db
-    .selectFrom("client")
-    .selectAll()
-    .where("encryption_public_key", "=", encPubKey)
-    .where("signature_public_key", "=", sigPubKey)
-    .limit(1)
-    .executeTakeFirst();
-  return client
-    ? ({
-        id: client.id,
-        encPubKey: client.encryption_public_key,
-        sigPubKey: client.signature_public_key,
-      } satisfies Client)
-    : null;
-};
-
-export const createUserClient = async (userId: number, clientId: number) => {
-  try {
-    await db.insertInto("user_client").values({ user_id: userId, client_id: clientId }).execute();
-  } catch (e) {
-    if (e instanceof pg.DatabaseError && e.code === "23505") {
-      throw new IntegrityError("User client already exists");
-    }
-    throw e;
-  }
-};
-
-export const getUserClient = async (userId: number, clientId: number) => {
-  const userClient = await db
-    .selectFrom("user_client")
-    .selectAll()
-    .where("user_id", "=", userId)
-    .where("client_id", "=", clientId)
-    .limit(1)
-    .executeTakeFirst();
-  return userClient
-    ? ({
-        userId: userClient.user_id,
-        clientId: userClient.client_id,
-        state: userClient.state,
-      } satisfies UserClient)
-    : null;
-};
-
-export const getUserClientWithDetails = async (userId: number, clientId: number) => {
-  const userClient = await db
-    .selectFrom("user_client")
-    .innerJoin("client", "user_client.client_id", "client.id")
-    .selectAll()
-    .where("user_id", "=", userId)
-    .where("client_id", "=", clientId)
-    .limit(1)
-    .executeTakeFirst();
-  return userClient
-    ? ({
-        userId: userClient.user_id,
-        clientId: userClient.client_id,
-        state: userClient.state,
-        encPubKey: userClient.encryption_public_key,
-        sigPubKey: userClient.signature_public_key,
-      } satisfies UserClientWithDetails)
-    : null;
-};
-
-export const setUserClientStateToPending = async (userId: number, clientId: number) => {
-  await db
-    .updateTable("user_client")
-    .set({ state: "pending" })
-    .where("user_id", "=", userId)
-    .where("client_id", "=", clientId)
-    .where("state", "=", "challenging")
-    .execute();
-};
-
-export const setUserClientStateToActive = async (userId: number, clientId: number) => {
-  await db
-    .updateTable("user_client")
-    .set({ state: "active" })
-    .where("user_id", "=", userId)
-    .where("client_id", "=", clientId)
-    .where("state", "=", "pending")
-    .execute();
-};
-
-export const registerUserClientChallenge = async (
-  userId: number,
-  clientId: number,
-  answer: string,
-  allowedIp: string,
-  expiresAt: Date,
-) => {
-  const { id } = await db
-    .insertInto("user_client_challenge")
-    .values({
-      user_id: userId,
-      client_id: clientId,
-      answer,
-      allowed_ip: allowedIp,
-      expires_at: expiresAt,
-    })
-    .returning("id")
-    .executeTakeFirstOrThrow();
-  return { id };
-};
-
-export const consumeUserClientChallenge = async (
-  challengeId: number,
-  userId: number,
-  ip: string,
-) => {
-  const challenge = await db
-    .deleteFrom("user_client_challenge")
-    .where("id", "=", challengeId)
-    .where("user_id", "=", userId)
-    .where("allowed_ip", "=", ip)
-    .where("expires_at", ">", new Date())
-    .returning(["client_id", "answer"])
-    .executeTakeFirst();
-  return challenge ? { clientId: challenge.client_id, answer: challenge.answer } : null;
-};
-
-export const cleanupExpiredUserClientChallenges = async () => {
-  await db.deleteFrom("user_client_challenge").where("expires_at", "<=", new Date()).execute();
-};

src/lib/server/db/dialect.ts

@@ -0,0 +1,22 @@
+import { PostgresDialect } from "kysely";
+import pg from "pg";
+
+export interface DatabaseConfig {
+  host?: string;
+  port?: number;
+  user?: string;
+  password?: string;
+  name?: string;
+}
+
+export const createDialect = (config: DatabaseConfig) => {
+  return new PostgresDialect({
+    pool: new pg.Pool({
+      host: config.host,
+      port: config.port,
+      user: config.user,
+      password: config.password,
+      database: config.name,
+    }),
+  });
+};