Added Library page, local dev mode

fly.staging.toml

···
 [build]
   dockerfile = "Dockerfile"
 
-[[restart]]
-  policy = "on-failure"
-  retries = 10
-  processes = ["app"]
-
 [env]
   PORT = "8088"
-  # Public base URL for OAuth client metadata & redirect URI
-  # If you use a custom staging domain, change this accordingly.
   CLIENT_URI = "https://staging.tapapp.lol"
 
 [http_service]

fly.toml

···
 
 [env]
   PORT = "8088"
+  CLIENT_URI = "https://tapapp.lol"
 
 [http_service]
   internal_port = 8088

server/main.go

···
 	userSessions = map[string]Session{}
 )
 
+// DEV_OFFLINE enables local, in-memory docs and a stub session for development
+var devOffline = getEnv("DEV_OFFLINE", "") == "1"
+
+// In-memory docs store for DEV_OFFLINE, keyed by our legacy session ID
+type devDoc struct {
+	ID        string
+	Name      string
+	Text      string
+	UpdatedAt string
+}
+var devDocsMu sync.Mutex
+var devDocs = map[string]map[string]*devDoc{}
+func devGetStore(sid string) map[string]*devDoc {
+	devDocsMu.Lock()
+	defer devDocsMu.Unlock()
+	m, ok := devDocs[sid]
+	if !ok { m = map[string]*devDoc{}; devDocs[sid] = m }
+	return m
+}
+
 // handleDocs lists and creates documents in lol.tapapp.tap.doc
 func handleDocs(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	if devOffline {
+		// Local in-memory implementation for development
+		sid := getOrCreateSessionID(w, r)
+		store := devGetStore(sid)
+		switch r.Method {
+		case http.MethodGet:
+			type item struct {
+				ID        string `json:"id"`
+				Name      string `json:"name"`
+				UpdatedAt string `json:"updatedAt"`
+			}
+			out := make([]item, 0, len(store))
+			for _, d := range store {
+				out = append(out, item{ID: d.ID, Name: d.Name, UpdatedAt: d.UpdatedAt})
+			}
+			_ = json.NewEncoder(w).Encode(out)
+			return
+		case http.MethodPost:
+			r.Body = http.MaxBytesReader(w, r.Body, maxJSONBody)
+			var body struct{ Name, Text string }
+			if err := json.NewDecoder(r.Body).Decode(&body); err != nil { http.Error(w, "invalid json", http.StatusBadRequest); return }
+			if body.Name == "" { body.Name = "Untitled" }
+			rb := make([]byte, 8); _, _ = rand.Read(rb); id := "d-" + hex.EncodeToString(rb)
+			now := time.Now().UTC().Format(time.RFC3339)
+			store[id] = &devDoc{ID: id, Name: body.Name, Text: body.Text, UpdatedAt: now}
+			w.WriteHeader(http.StatusCreated)
+			_ = json.NewEncoder(w).Encode(map[string]string{"id": id})
+			return
+		default:
+			w.WriteHeader(http.StatusMethodNotAllowed); return
+		}
+	}
 	did, _, ok := getDIDAndHandle(r)
 	if !ok {
 		w.WriteHeader(http.StatusNoContent)
···
 
 // handleDocByID gets/updates/deletes a document by rkey
 func handleDocByID(w http.ResponseWriter, r *http.Request) {
+	if devOffline {
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+		id := strings.TrimPrefix(r.URL.Path, "/docs/")
+		if id == "" { w.WriteHeader(http.StatusBadRequest); return }
+		sid := getOrCreateSessionID(w, r)
+		store := devGetStore(sid)
+		switch r.Method {
+		case http.MethodGet:
+			// PDF export support in offline mode
+			if strings.HasSuffix(id, ".pdf") {
+				baseID := strings.TrimSuffix(id, ".pdf")
+				d, ok := store[baseID]; if !ok { http.Error(w, "not found", http.StatusNotFound); return }
+				name := d.Name; if name == "" { name = "Untitled" }
+				blocks := fountain.Parse(d.Text)
+				pdfBytes, err := renderPDF(blocks, name)
+				if err != nil { log.Printf("pdf render error: %v", err); http.Error(w, "PDF render failed", http.StatusInternalServerError); return }
+				safeName := sanitizeFilename(name)
+				// Override content-type for PDF
+				w.Header().Del("Content-Type")
+				w.Header().Set("Content-Type", "application/pdf")
+				w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s.pdf\"", safeName))
+				w.Header().Set("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0")
+				w.Header().Set("Pragma", "no-cache"); w.Header().Set("Expires", "0")
+				_, _ = w.Write(pdfBytes)
+				return
+			}
+			// Plain text export (.fountain)
+			if strings.HasSuffix(id, ".fountain") {
+				baseID := strings.TrimSuffix(id, ".fountain")
+				d, ok := store[baseID]; if !ok { http.Error(w, "not found", http.StatusNotFound); return }
+				w.Header().Del("Content-Type")
+				w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+				name := d.Name; if name == "" { name = "screenplay" }
+				w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s.fountain\"", sanitizeFilename(name)))
+				_, _ = w.Write([]byte(d.Text))
+				return
+			}
+			// Delete via action query (for simple UI link)
+			if r.URL.Query().Get("action") == "delete" {
+				if _, ok := store[id]; !ok { http.Error(w, "not found", http.StatusNotFound); return }
+				delete(store, id)
+				http.Redirect(w, r, "/library", http.StatusSeeOther)
+				return
+			}
+			d, ok := store[id]; if !ok { http.Error(w, "not found", http.StatusNotFound); return }
+			_ = json.NewEncoder(w).Encode(map[string]any{"id": d.ID, "name": d.Name, "text": d.Text, "updatedAt": d.UpdatedAt})
+			return
+		case http.MethodPut:
+			var body struct{ Name *string `json:"name"`; Text *string `json:"text"` }
+			r.Body = http.MaxBytesReader(w, r.Body, maxJSONBody)
+			if err := json.NewDecoder(r.Body).Decode(&body); err != nil { http.Error(w, "invalid json", http.StatusBadRequest); return }
+			d, ok := store[id]; if !ok { http.Error(w, "not found", http.StatusNotFound); return }
+			if body.Name != nil { n := strings.TrimSpace(*body.Name); if n == "" { n = "Untitled" }; d.Name = n }
+			if body.Text != nil { d.Text = *body.Text }
+			d.UpdatedAt = time.Now().UTC().Format(time.RFC3339)
+			w.WriteHeader(http.StatusNoContent)
+			return
+		case http.MethodDelete:
+			if _, ok := store[id]; !ok { http.Error(w, "not found", http.StatusNotFound); return }
+			delete(store, id)
+			w.WriteHeader(http.StatusNoContent)
+			return
+		default:
+			w.WriteHeader(http.StatusMethodNotAllowed); return
+		}
+	}
 	did, handle, ok := getDIDAndHandle(r)
 	if !ok {
 		w.Header().Set("Content-Type", "application/json; charset=utf-8")
···
 	switch r.Method {
 	case http.MethodGet:
 		s2 := Session{DID: did, Handle: handle}
+		// Plain text export
+		if strings.HasSuffix(id, ".fountain") {
+			baseID := strings.TrimSuffix(id, ".fountain")
+			name, text, status, err := getDocNameAndText(w, r, r.Context(), s2, baseID)
+			if err != nil { w.WriteHeader(status); return }
+			w.Header().Del("Content-Type")
+			w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+			if name == "" { name = "screenplay" }
+			w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s.fountain\"", sanitizeFilename(name)))
+			_, _ = w.Write([]byte(text))
+			return
+		}
+		// Delete via action query
+		if r.URL.Query().Get("action") == "delete" {
+			// Delete record on PDS
+			delPayload := map[string]any{"repo": did, "collection": "lol.tapapp.tap.doc", "rkey": id}
+			dbuf, _ := json.Marshal(delPayload)
+			delURL := pdsBaseFromUser(r) + "/xrpc/com.atproto.repo.deleteRecord"
+			dRes, err := pdsRequest(w, r, http.MethodPost, delURL, "application/json", dbuf)
+			if err != nil { http.Error(w, "delete failed", http.StatusBadGateway); return }
+			defer dRes.Body.Close()
+			if dRes.StatusCode < 200 || dRes.StatusCode >= 300 { w.WriteHeader(dRes.StatusCode); return }
+			http.Redirect(w, r, "/library", http.StatusSeeOther)
+			return
+		}
 		name, text, status, err := getDocNameAndText(w, r, r.Context(), s2, id)
 		if err != nil { w.WriteHeader(status); return }
 		_ = json.NewEncoder(w).Encode(map[string]any{"id": id, "name": name, "text": text, "updatedAt": ""})
···
 		s, ok := userSessions[sid]
 		sessionsMu.Unlock()
 		if !ok || s.DID == "" {
+			if devOffline {
+				// Provide a stub session in offline mode so UI treats user as logged in
+				stub := Session{DID: "did:example:dev", Handle: "dev.local"}
+				sessionsMu.Lock(); userSessions[sid] = stub; sessionsMu.Unlock()
+				_ = json.NewEncoder(w).Encode(stub)
+				return
+			}
 			w.WriteHeader(http.StatusNoContent)
 			return
 		}
···
 	mux.HandleFunc("/about", handleAbout)
 	mux.HandleFunc("/privacy", handlePrivacy)
 	mux.HandleFunc("/terms", handleTerms)
+	mux.HandleFunc("/library", handleLibrary)
 	mux.HandleFunc("/health", handleHealth)
 	mux.HandleFunc("/preview", handlePreview)
 	// Multi-doc (ATProto-backed)
···
 		Title: "Terms of Service",
 	}
 	render(w, "terms.html", data)
+}
+
+func handleLibrary(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Cache-Control", "no-cache")
+	data := struct{ Title string }{Title: "Library - Tap"}
+	render(w, "library.html", data)
 }
 
 func handleHealth(w http.ResponseWriter, r *http.Request) {

server/templates/library.html

···
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>{{ .Title }}</title>
+  <link rel="stylesheet" href="/static/styles.css"/>
+</head>
+<body>
+  <header class="container header">
+    <h1 class="brand">
+      <a href="/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="/static/images/tap-logo-dark.svg">
+          <source media="(prefers-color-scheme: light)" srcset="/static/images/tap-logo-light.svg">
+          <img class="brand-logo" src="/static/images/tap-og.png" alt="" aria-hidden="true" width="120" height="120">
+        </picture>
+        <span class="brand-text">Tap</span>
+      </a>
+    </h1>
+    <nav>
+      <a href="/library" class="sp">Library</a>
+      <a href="/" class="sp">Editor</a>
+      <span id="header-user" class="sp" style="margin-left:12px; opacity:.85; display:none"></span>
+      <button id="header-logout" class="sp" style="display:none">Logout</button>
+    </nav>
+  </header>
+
+  <main class="container">
+    <div style="display:flex; justify-content:space-between; align-items:center; gap:12px; margin: 12px 0 8px">
+      <h2 style="margin:0">Library</h2>
+      <div class="actions">
+        <button id="lib-new" type="button">New</button>
+      </div>
+    </div>
+    <div id="list" class="list" style="display:grid; gap:6px"></div>
+  </main>
+
+  <footer class="container footer">
+    <p>
+      <span class="footer-left">
+        <a href="/about">About</a>
+        • <a href="/privacy">Privacy Policy</a>
+        • <a href="/terms">Terms of Service</a>
+      </span>
+      <span class="footer-right">
+        &copy; <a href="https://limeleaf.coop" target="_blank" rel="noreferrer">Limeleaf Worker Collective</a>
+      </span>
+    </p>
+  </footer>
+
+  <script>
+    document.addEventListener('DOMContentLoaded', () => {
+    console.info('Library page script loaded');
+    const list = document.getElementById('list');
+    const btnNew = document.getElementById('lib-new');
+    const userEl = document.getElementById('header-user');
+    const btnLogout = document.getElementById('header-logout');
+
+    async function refreshHeader() {
+      try {
+        const res = await fetch('/atp/session');
+        if (res.ok && res.status !== 204) {
+          const s = await res.json();
+          userEl.textContent = s?.handle || '';
+          userEl.style.display = s?.handle ? 'inline' : 'none';
+          btnLogout.style.display = s?.handle ? 'inline-block' : 'none';
+        } else {
+          userEl.textContent = '';
+          userEl.style.display = 'none';
+          btnLogout.style.display = 'none';
+        }
+      } catch {
+        userEl.style.display = 'none';
+        btnLogout.style.display = 'none';
+      }
+    }
+
+    // Disable delegated capture handlers to avoid interfering with inline/button handlers
+    // (Open/Export/PDF/Delete use anchors; Rename uses inline onclick + direct handler.)
+
+    async function loadList() {
+      list.innerHTML = '<div style="opacity:.75">Loading…</div>';
+      try {
+        const res = await fetch('/docs');
+        if (!res.ok) { list.innerHTML = '<div style="opacity:.75">Failed to load</div>'; return; }
+        const arr = await res.json();
+        const docs = Array.isArray(arr) ? arr : [];
+        if (!docs.length) {
+          list.innerHTML = '<div style="opacity:.75">No documents yet</div>';
+          return;
+        }
+        const html = docs
+          .sort((a,b)=> new Date(b.updatedAt).getTime()-new Date(a.updatedAt).getTime())
+          .map(d => `
+            <div class="doc" data-id="${escapeHtml(d.id)}" data-name="${escapeHtml(d.name||'Untitled')}" style="display:flex; align-items:center; justify-content: space-between; gap:12px; padding:10px 12px; border:1px solid #e5e7eb; border-radius:10px; cursor:pointer">
+              <div>
+                <div class="name"><a href="/?id=${encodeURIComponent(d.id)}" style="text-decoration:none; color:inherit">${escapeHtml(d.name||'Untitled')}</a></div>
+                <div class="meta" style="font-size:12px; opacity:.75">Updated ${new Date(d.updatedAt).toLocaleString()}</div>
+              </div>
+              <div class="actions" style="display:flex; gap:8px">
+                <a href="/?id=${encodeURIComponent(d.id)}" class="btn" style="padding:6px 10px; border:1px solid #e5e7eb; border-radius:8px; text-decoration:none">Open</a>
+                <button data-rename type="button" onclick="return window.__tapRename ? window.__tapRename(this) : false;">Rename</button>
+                <a href="/docs/${encodeURIComponent(d.id)}.fountain" class="btn" style="padding:6px 10px; border:1px solid #e5e7eb; border-radius:8px; text-decoration:none">Export</a>
+                <a href="/docs/${encodeURIComponent(d.id)}.pdf" class="btn" style="padding:6px 10px; border:1px solid #e5e7eb; border-radius:8px; text-decoration:none">PDF</a>
+                <a href="/docs/${encodeURIComponent(d.id)}?action=delete" class="btn" style="padding:6px 10px; border:1px solid #e5e7eb; border-radius:8px; text-decoration:none" onclick="return confirm('Delete this document? This cannot be undone.');">Delete</a>
+              </div>
+            </div>
+          `).join('');
+        list.innerHTML = html;
+        // Fallback: also bind per-button handlers in case delegation is bypassed
+        list.querySelectorAll('[data-open]').forEach(btn => btn.addEventListener('click', (e) => {
+          e.preventDefault(); e.stopPropagation();
+          const card = (e.currentTarget).closest('.doc');
+          const id = card?.getAttribute('data-id') || '';
+          if (!id) return;
+          console.debug('Library: open (direct)', id);
+          window.location.href = '/?id=' + encodeURIComponent(id);
+        }));
+        list.querySelectorAll('[data-rename]').forEach(btn => btn.addEventListener('click', async (e) => {
+          e.preventDefault(); e.stopPropagation();
+          const card = (e.currentTarget).closest('.doc');
+          if (card) startInlineRename(card);
+        }));
+        list.querySelectorAll('[data-export]').forEach(btn => btn.addEventListener('click', async (e) => {
+          e.preventDefault(); e.stopPropagation();
+          const card = (e.currentTarget).closest('.doc');
+          const id = card?.getAttribute('data-id') || '';
+          const name = (card?.getAttribute('data-name') || 'screenplay').replace(/[\\/:*?\"<>|]+/g, '-');
+          if (!id) return;
+          try {
+            const res = await fetch('/docs/' + encodeURIComponent(id));
+            if (!res.ok) { alert('Export failed'); return; }
+            const d = await res.json();
+            const text = (d?.text || '').toString();
+            const blob = new Blob([text], { type: 'text/plain;charset=utf-8' });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url; a.download = name + '.fountain'; a.click();
+            URL.revokeObjectURL(url);
+          } catch { alert('Export failed'); }
+        }));
+        list.querySelectorAll('[data-export-pdf]').forEach(btn => btn.addEventListener('click', (e) => {
+          e.preventDefault(); e.stopPropagation();
+          const card = (e.currentTarget).closest('.doc');
+          const id = card?.getAttribute('data-id') || '';
+          if (!id) return;
+          window.location.href = '/docs/' + encodeURIComponent(id) + '.pdf';
+        }));
+        list.querySelectorAll('[data-delete]').forEach(btn => btn.addEventListener('click', async (e) => {
+          e.preventDefault(); e.stopPropagation();
+          const card = (e.currentTarget).closest('.doc');
+          const id = card?.getAttribute('data-id') || '';
+          if (!id) return;
+          const cur = card?.getAttribute('data-name') || 'Untitled';
+          if (!window.confirm(`Delete "${cur}"? This cannot be undone.`)) return;
+          try { const res = await fetch('/docs/' + encodeURIComponent(id), { method: 'DELETE' }); if (!res.ok) { alert('Delete failed'); return; } await loadList(); }
+          catch { alert('Delete failed'); }
+        }));
+      } catch (e) {
+        list.innerHTML = '<div style="opacity:.75">Failed to load</div>';
+      }
+    }
+
+    function onListClick(e) {
+      // Normalize target to an Element (text nodes don't have closest)
+      var target = e.target;
+      if (target && target.nodeType === 3 /* TEXT_NODE */) {
+        target = target.parentNode;
+      }
+      if (!target || !target.closest) return;
+      // Use composedPath to improve reliability across shadow DOMs
+      var path = typeof e.composedPath === 'function' ? e.composedPath() : [];
+      // Find the card element
+      var card = target.closest('.doc');
+      if (!card && Array.isArray(path)) {
+        for (var i = 0; i < path.length; i++) {
+          var n = path[i];
+          if (n && n.closest) { var c = n.closest('.doc'); if (c) { card = c; break; } }
+        }
+      }
+      if (!card) return;
+      const id = card.getAttribute('data-id') || '';
+      if (!id) return;
+      var actionEl = target.closest('[data-open],[data-rename],[data-export],[data-export-pdf],[data-delete]');
+      if (!actionEl && Array.isArray(path)) {
+        for (var j = 0; j < path.length; j++) {
+          var m = path[j];
+          if (m && m.matches && m.matches('[data-open],[data-rename],[data-export],[data-export-pdf],[data-delete]')) { actionEl = m; break; }
+        }
+      }
+      console.info('Library: onListClick target=', target, 'actionEl=', actionEl);
+      if (actionEl && actionEl.hasAttribute('data-open')) {
+        e.preventDefault(); e.stopPropagation();
+        console.debug('Library: open', id);
+        window.location.href = '/?id=' + encodeURIComponent(id);
+        return;
+      }
+      if (actionEl && actionEl.hasAttribute('data-rename')) {
+        // Let the inline onclick handler run (do not prevent/stop here)
+        console.debug('Library: rename (delegated pass-through)', id);
+        return;
+      }
+      if (actionEl && actionEl.hasAttribute('data-export')) {
+        e.preventDefault(); e.stopPropagation();
+        const name = (card.getAttribute('data-name') || 'screenplay').replace(/[\\/:*?\"<>|]+/g, '-');
+        fetch('/docs/' + encodeURIComponent(id))
+          .then(res => { if (!res.ok) throw new Error('bad'); return res.json(); })
+          .then(d => {
+            const text = (d?.text || '').toString();
+            const blob = new Blob([text], { type: 'text/plain;charset=utf-8' });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url; a.download = name + '.fountain'; a.click();
+            URL.revokeObjectURL(url);
+          })
+          .catch(() => alert('Export failed'));
+        return;
+      }
+      if (actionEl && actionEl.hasAttribute('data-export-pdf')) {
+        e.preventDefault(); e.stopPropagation();
+        window.location.href = '/docs/' + encodeURIComponent(id) + '.pdf';
+        return;
+      }
+      if (actionEl && actionEl.hasAttribute('data-delete')) {
+        e.preventDefault(); e.stopPropagation();
+        const cur = card.getAttribute('data-name') || 'Untitled';
+        if (!window.confirm(`Delete "${cur}"? This cannot be undone.`)) return;
+        fetch('/docs/' + encodeURIComponent(id), { method: 'DELETE' })
+          .then(res => { if (!res.ok) throw new Error('bad'); return; })
+          .then(() => loadList())
+          .catch(() => alert('Delete failed'));
+        return;
+      }
+      // Clicked the card background: open (but allow anchor default behavior)
+      if (!actionEl && !(target && target.closest && target.closest('a'))) {
+        e.preventDefault();
+        console.debug('Library: open (card)', id);
+        window.location.href = '/?id=' + encodeURIComponent(id);
+      }
+    }
+
+    // (Removed separate startInlineRename; use global __tapRename below)
+
+    function escapeHtml(s) {
+      const str = s == null ? '' : String(s);
+      return str.replace(/[&<>"]/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]));
+    }
+
+    btnLogout.addEventListener('click', async () => {
+      try { await fetch('/atp/session', { method: 'DELETE' }); } catch {}
+      window.location.href = '/';
+    });
+
+    btnNew.addEventListener('click', async () => {
+      try {
+        const res = await fetch('/docs', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 'Untitled', text: '' }) });
+        if (!res.ok) { alert('Create failed'); return; }
+        const d = await res.json();
+        const id = d?.id || d?.rkey;
+        if (id) window.location.href = '/?id=' + encodeURIComponent(id);
+      } catch { alert('Create failed'); }
+    });
+
+    (async () => { await refreshHeader(); await loadList(); })();
+    // Expose a global rename helper for inline onclick wiring (self-contained)
+    window.__tapRename = function(el){
+      try {
+        var card = el && el.closest ? el.closest('.doc') : null;
+        if (!card) return false;
+        var nameEl = card.querySelector('.name');
+        if (!nameEl) return false;
+        var id = card.getAttribute('data-id') || '';
+        if (!id) return false;
+        var cur = card.getAttribute('data-name') || 'Untitled';
+        // Avoid creating multiple inputs
+        if (card.querySelector('input[data-rename-input]')) return false;
+        var input = document.createElement('input');
+        input.type = 'text';
+        input.value = cur;
+        input.setAttribute('data-rename-input', '');
+        input.style.fontSize = '16px';
+        input.style.padding = '4px 6px';
+        input.style.border = '1px solid #d1d5db';
+        input.style.borderRadius = '6px';
+        var old = nameEl.innerHTML;
+        nameEl.innerHTML = '';
+        nameEl.appendChild(input);
+        input.focus(); input.select();
+        var committed = false;
+        var commit = function(){
+          if (committed) return; committed = true;
+          var next = (input.value || '').trim();
+          if (!next || next === cur) { nameEl.innerHTML = old; return; }
+          fetch('/docs/' + encodeURIComponent(id), {
+            method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: next })
+          }).then(function(res){ if (!res.ok && res.status !== 204) throw new Error('bad'); })
+            .then(function(){ return loadList(); })
+            .catch(function(err){ console.warn('rename failed', err); alert('Rename failed'); nameEl.innerHTML = old; });
+        };
+        input.addEventListener('keydown', function(ke){ if (ke.key === 'Enter') { ke.preventDefault(); commit(); } if (ke.key === 'Escape') { ke.preventDefault(); nameEl.innerHTML = old; committed = true; } });
+        input.addEventListener('blur', function(){ commit(); });
+      } catch (e) { console.warn('global rename error', e); }
+      return false;
+    };
+    });
+  </script>
+</body>
+</html>

web/components/tap-app.ts

···
       // Load docs list and open latest, else fallback to legacy single-doc, else create new
       try {
         await this.loadDocsList();
-        if (this.docs.length > 0) {
-          // open most recent by updatedAt
+        // If URL includes ?id=..., open that doc explicitly; otherwise, open most recent
+        const url = new URL(window.location.href);
+        const qid = (url.searchParams.get('id') || '').trim();
+        if (qid) {
+          await this.openDoc(qid);
+        } else if (this.docs.length > 0) {
           const sorted = [...this.docs].sort((a,b)=> new Date(b.updatedAt).getTime()-new Date(a.updatedAt).getTime());
           await this.openDoc(sorted[0].id);
         } else {
···
 
     // Library and multi-doc handlers
     this.root.addEventListener('open-library', async () => {
-      await this.loadDocsList();
-      this.showLibrary = true; this.setAttribute('show-library','');
-      this.renderLibrary();
+      // Navigate to standalone Library page
+      window.location.href = '/library';
     });
     this.root.addEventListener('new-doc', async () => {
       await this.createDoc();