fixing gitignore

assets/scripts/comments.js

@@ -0,0 +1,197 @@
+let pageSlug = null;
+
+/* -----------------------------
+ * DOM builders
+ * ----------------------------- */
+
+
+function showReplyForm(container, parentId) {
+  if (container.querySelector(".reply-form")) return;
+
+  const form = document.createElement("form");
+  form.className = "reply-form";
+
+  form.innerHTML = `
+    <input type="text" name="author" placeholder="Your name (optional)">
+    <textarea name="content" required placeholder="Write a reply..."></textarea>
+    <button type="submit">Post reply</button>
+  `;
+
+  form.addEventListener("submit", async e => {
+    e.preventDefault();
+
+    const author = form.author.value.trim();
+    const content = form.content.value.trim();
+    if (!content) return;
+
+    const ok = await postComment(author, content, parentId);
+    if (ok) loadComments();
+    else alert("Failed to post reply");
+  });
+
+  container.appendChild(form);
+}
+
+function createComment(comment) {
+  const wrapper = document.createElement("div");
+  wrapper.className = "comment";
+  wrapper.dataset.id = comment.id;
+
+  const author = document.createElement("strong");
+  author.textContent = comment.author || "Anonymous";
+
+  const body = document.createElement("p");
+  body.textContent = comment.content;
+
+  const time = document.createElement("time");
+  time.className = "comment-date";
+  time.dateTime = comment.created_at;
+  time.textContent = new Date(comment.created_at).toLocaleString();
+
+  const replyBtn = document.createElement("button");
+  replyBtn.className = "comment-reply";
+  replyBtn.textContent = "Reply";
+  replyBtn.onclick = () =>
+    showReplyForm(wrapper, Number(comment.id));
+
+  wrapper.append(author, body, time, replyBtn);
+
+  if (comment.children?.length) {
+    const replies = document.createElement("div");
+    replies.className = "comment-children";
+
+    comment.children.forEach(child => {
+      replies.appendChild(createComment(child));
+    });
+
+    wrapper.appendChild(replies);
+  }
+  console.log("PARENT_ID RECEIVED:", comment.parent_id)
+
+  return wrapper;
+}
+
+
+
+function buildCommentTree(comments) {
+  const byId = {};
+  const roots = [];
+
+  comments.forEach(c => {
+    c.children = [];
+    byId[c.id] = c;
+  });
+
+  comments.forEach(c => {
+    if (c.parent_id) {
+      const parent = byId[c.parent_id];
+      if (parent) parent.children.push(c);
+    } else {
+      roots.push(c);
+    }
+  });
+
+  return roots;
+}
+
+
+/* -----------------------------
+ * Rendering
+ * ----------------------------- */
+
+function renderComments(comments) {
+  const list = document.getElementById("comments-list");
+  list.innerHTML = "";
+
+  if (!comments.length) {
+    const empty = document.createElement("p");
+    empty.className = "comments-empty";
+    empty.textContent = "No comments yet.";
+    list.appendChild(empty);
+    return;
+  }
+
+  const tree = buildCommentTree(comments);
+  tree.forEach(c => list.appendChild(createComment(c)));
+}
+
+
+/* -----------------------------
+ * API
+ * ----------------------------- */
+
+async function fetchComments() {
+  const res = await fetch(`/api/comments/${pageSlug}`);
+  if (!res.ok) {
+    console.error("Failed to fetch comments");
+    return [];
+  }
+  return await res.json();
+}
+
+async function postComment(author, content, parentId = null) {
+  const res = await fetch("/api/comments", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      page_slug: pageSlug,
+      author: author || null,
+      content,
+      parent_id: parentId
+    })
+  });
+
+  return res.ok;
+}
+
+
+
+/* -----------------------------
+ * Form handling
+ * ----------------------------- */
+
+function wireCommentForm() {
+  const form = document.getElementById("comment-form");
+
+  form.addEventListener("submit", async e => {
+    e.preventDefault();
+
+    const authorInput = form.querySelector("input[name='author']");
+    const textarea    = form.querySelector("textarea[name='content']");
+
+    const author  = authorInput.value.trim();
+    const content = textarea.value.trim();
+
+    if (!content) return;
+
+    const ok = await postComment(author, content);
+    if (ok) {
+      textarea.value = "";
+      loadComments();   // same pattern as your Kanban board
+    } else {
+      alert("Failed to post comment");
+    }
+  });
+}
+
+
+/* -----------------------------
+ * Entry point
+ * ----------------------------- */
+
+async function loadComments() {
+  const comments = await fetchComments();
+  renderComments(comments);
+}
+
+function initComments() {
+  const section = document.getElementById("comments");
+  if (!section) return;
+
+  pageSlug = section.dataset.slug;
+
+  wireCommentForm();
+  loadComments();
+}
+
+initComments();

assets/scripts/comments.js~

@@ -0,0 +1,127 @@
+let pageSlug = null;
+
+/* -----------------------------
+ * DOM builders
+ * ----------------------------- */
+
+function createComment(comment) {
+  const wrapper = document.createElement("div");
+  wrapper.className = "comment";
+  wrapper.dataset.id = comment.id;
+
+  const author = document.createElement("strong");
+  author.textContent = comment.author || "Anonymous";
+
+  const body = document.createElement("p");
+  body.textContent = comment.content;
+
+  const time = document.createElement("time");
+  time.className = "comment-date";
+  time.dateTime = comment.created_at;
+  time.textContent = new Date(comment.created_at).toLocaleString();
+
+  wrapper.appendChild(author);
+  wrapper.appendChild(body);
+  wrapper.appendChild(time);
+
+  return wrapper;
+}
+
+/* -----------------------------
+ * Rendering
+ * ----------------------------- */
+
+function renderComments(comments) {
+  const list = document.getElementById("comments-list");
+  list.innerHTML = "";
+
+  if (!comments.length) {
+    const empty = document.createElement("p");
+    empty.className = "comments-empty";
+    empty.textContent = "No comments yet.";
+    list.appendChild(empty);
+    return;
+  }
+
+  comments.forEach(c => {
+    list.appendChild(createComment(c));
+  });
+}
+
+/* -----------------------------
+ * API
+ * ----------------------------- */
+
+async function fetchComments() {
+  const res = await fetch(`/api/comments/${pageSlug}`);
+  if (!res.ok) {
+    console.error("Failed to fetch comments");
+    return [];
+  }
+  return await res.json();
+}
+
+async function postComment(author, content) {
+  const res = await fetch("/api/comments", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      page_slug: pageSlug,
+      author: author || null,
+      content: content
+    })
+  });
+
+  return res.ok;
+}
+
+
+/* -----------------------------
+ * Form handling
+ * ----------------------------- */
+
+function wireCommentForm() {
+  const form = document.getElementById("comment-form");
+
+  form.addEventListener("submit", async e => {
+    e.preventDefault();
+
+    const authorInput = form.querySelector("input[name='author']");
+    const textarea    = form.querySelector("textarea[name='content']");
+
+    const author  = authorInput.value.trim();
+    const content = textarea.value.trim();
+
+    if (!content) return;
+
+    const ok = await postComment(author, content);
+    if (ok) {
+      textarea.value = "";
+      loadComments();   // same pattern as your Kanban board
+    } else {
+      alert("Failed to post comment");
+    }
+  });
+}
+
+
+/* -----------------------------
+ * Entry point
+ * ----------------------------- */
+
+async function loadComments() {
+  const comments = await fetchComments();
+  renderComments(comments);
+}
+
+function initComments() {
+  const section = document.getElementById("comments");
+  if (!section) return;
+
+  pageSlug = section.dataset.slug;
+
+  wireCommentForm();
+  loadComments();
+}
+
+initComments();

assets/scripts/competency-status-board.js

@@ -0,0 +1,169 @@
+const STATES = [
+  { key: "completed",    label: "Completed" },
+  { key: "manager_review",  label: "Manager Review" },
+  { key: "in_progress",   label: "In Progress" },
+  { key: "not_started",    label: "Not Started" },
+  { key: "comments",    label: "Comments" }
+];
+
+function isMobile() {
+  return window.matchMedia("(max-width: 600px)").matches;
+}
+
+function populateMobileControls(items) {
+  if (!isMobile()) return;
+
+  const panel = document.getElementById("mobile-move-panel");
+  const itemSelect = document.getElementById("move-item");
+  const fromSelect = document.getElementById("move-from");
+  const toSelect = document.getElementById("move-to");
+
+  itemSelect.innerHTML = "<option value=''>Select competency</option>";
+  fromSelect.innerHTML = "<option value=''>From</option>";
+  toSelect.innerHTML   = "<option value=''>To</option>";
+
+  items.forEach(item => {
+    const opt = document.createElement("option");
+    opt.value = item.id;
+    opt.textContent = item.title;
+    opt.dataset.state = item.state;
+    itemSelect.appendChild(opt);
+  });
+
+  STATES.forEach(s => {
+    fromSelect.appendChild(new Option(s.label, s.key));
+    toSelect.appendChild(new Option(s.label, s.key));
+  });
+
+  // Auto-fill "from" when item selected
+  itemSelect.onchange = () => {
+    const selected = itemSelect.selectedOptions[0];
+    if (selected?.dataset.state) {
+      fromSelect.value = selected.dataset.state;
+    }
+  };
+}
+
+document.getElementById("move-confirm").addEventListener("click", async () => {
+  const itemId = document.getElementById("move-item").value;
+  const from   = document.getElementById("move-from").value;
+  const to     = document.getElementById("move-to").value;
+
+  if (!itemId || !to) {
+    alert("Select an item and target column");
+    return;
+  }
+
+  if (from === to) {
+    alert("Item is already in that column");
+    return;
+  }
+
+  const res = await fetch(`/api/competencies/items/${itemId}/state`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ state: to })
+  });
+
+  if (res.ok) {
+    loadBoard();
+  } else {
+    alert("Failed to move competency");
+  }
+});
+
+
+
+let draggedItemId = null;
+
+function countByState(items) {
+  return items.reduce((acc, item) => {
+    acc[item.state] = (acc[item.state] || 0) + 1;
+    return acc;
+  }, {});
+}
+
+function createCard(item) {
+  const card = document.createElement("div");
+  card.className = "kanban-card";
+  card.draggable = true;
+  card.dataset.id = item.id;
+  card.textContent = item.title;
+
+  card.addEventListener("dragstart", () => {
+    draggedItemId = item.id;
+    card.classList.add("dragging");
+  });
+
+  card.addEventListener("dragend", () => {
+    draggedItemId = null;
+    card.classList.remove("dragging");
+  });
+
+  return card;
+}
+
+function createColumn(state, items, counts) {
+  const col = document.createElement("div");
+  col.className = "kanban-column";
+  col.dataset.state = state.key;
+
+  const header = document.createElement("h3");
+  header.innerHTML = `
+  <span class="kanban-title">${state.label}</span>
+  <span class="kanban-count">${counts[state.key] || 0}</span>
+`;
+  
+  const list = document.createElement("div");
+  list.className = "kanban-list";
+
+  list.addEventListener("dragover", e => e.preventDefault());
+
+  list.addEventListener("drop", async () => {
+    if (!draggedItemId) return;
+
+    const res = await fetch(`/api/competencies/items/${draggedItemId}/state`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ state: state.key })
+    });
+
+    if (res.ok) {
+      loadBoard(); // simple & safe re-render
+    } else {
+      alert("Failed to update state");
+    }
+  });
+
+  items
+    .filter(i => i.state === state.key)
+    .forEach(i => list.appendChild(createCard(i)));
+
+  col.appendChild(header);
+  col.appendChild(list);
+
+  return col;
+}
+
+function renderBoard(items) {
+  const board = document.getElementById("kanban-board");
+  if (!board) return;
+  board.innerHTML = "";
+
+  const counts = countByState(items);
+
+  STATES.forEach(state => {
+    board.appendChild(createColumn(state, items, counts));
+  });
+}
+
+
+async function loadBoard() {
+  const res = await fetch("/api/competencies/items");
+  const items = await res.json();
+  renderBoard(items);
+  populateMobileControls(items);
+}
+
+
+loadBoard();

assets/scripts/competency-status-board.js~

@@ -0,0 +1,168 @@
+const STATES = [
+  { key: "completed",    label: "Completed" },
+  { key: "manager_review",  label: "Manager Review" },
+  { key: "in_progress",   label: "In Progress" },
+  { key: "not_started",    label: "Not Started" },
+  { key: "comments",    label: "Comments" }
+];
+
+function isMobile() {
+  return window.matchMedia("(max-width: 600px)").matches;
+}
+
+function populateMobileControls(items) {
+  if (!isMobile()) return;
+
+  const panel = document.getElementById("mobile-move-panel");
+  const itemSelect = document.getElementById("move-item");
+  const fromSelect = document.getElementById("move-from");
+  const toSelect = document.getElementById("move-to");
+
+  itemSelect.innerHTML = "<option value=''>Select competency</option>";
+  fromSelect.innerHTML = "<option value=''>From</option>";
+  toSelect.innerHTML   = "<option value=''>To</option>";
+
+  items.forEach(item => {
+    const opt = document.createElement("option");
+    opt.value = item.id;
+    opt.textContent = item.title;
+    opt.dataset.state = item.state;
+    itemSelect.appendChild(opt);
+  });
+
+  STATES.forEach(s => {
+    fromSelect.appendChild(new Option(s.label, s.key));
+    toSelect.appendChild(new Option(s.label, s.key));
+  });
+
+  // Auto-fill "from" when item selected
+  itemSelect.onchange = () => {
+    const selected = itemSelect.selectedOptions[0];
+    if (selected?.dataset.state) {
+      fromSelect.value = selected.dataset.state;
+    }
+  };
+}
+
+document.getElementById("move-confirm").addEventListener("click", async () => {
+  const itemId = document.getElementById("move-item").value;
+  const from   = document.getElementById("move-from").value;
+  const to     = document.getElementById("move-to").value;
+
+  if (!itemId || !to) {
+    alert("Select an item and target column");
+    return;
+  }
+
+  if (from === to) {
+    alert("Item is already in that column");
+    return;
+  }
+
+  const res = await fetch(`/api/competencies/items/${itemId}/state`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ state: to })
+  });
+
+  if (res.ok) {
+    loadBoard();
+  } else {
+    alert("Failed to move competency");
+  }
+});
+
+
+
+let draggedItemId = null;
+
+function countByState(items) {
+  return items.reduce((acc, item) => {
+    acc[item.state] = (acc[item.state] || 0) + 1;
+    return acc;
+  }, {});
+}
+
+function createCard(item) {
+  const card = document.createElement("div");
+  card.className = "kanban-card";
+  card.draggable = true;
+  card.dataset.id = item.id;
+  card.textContent = item.title;
+
+  card.addEventListener("dragstart", () => {
+    draggedItemId = item.id;
+    card.classList.add("dragging");
+  });
+
+  card.addEventListener("dragend", () => {
+    draggedItemId = null;
+    card.classList.remove("dragging");
+  });
+
+  return card;
+}
+
+function createColumn(state, items, counts) {
+  const col = document.createElement("div");
+  col.className = "kanban-column";
+  col.dataset.state = state.key;
+
+  const header = document.createElement("h3");
+  header.innerHTML = `
+  <span class="kanban-title">${state.label}</span>
+  <span class="kanban-count">${counts[state.key] || 0}</span>
+`;
+  
+  const list = document.createElement("div");
+  list.className = "kanban-list";
+
+  list.addEventListener("dragover", e => e.preventDefault());
+
+  list.addEventListener("drop", async () => {
+    if (!draggedItemId) return;
+
+    const res = await fetch(`/api/competencies/items/${draggedItemId}/state`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ state: state.key })
+    });
+
+    if (res.ok) {
+      loadBoard(); // simple & safe re-render
+    } else {
+      alert("Failed to update state");
+    }
+  });
+
+  items
+    .filter(i => i.state === state.key)
+    .forEach(i => list.appendChild(createCard(i)));
+
+  col.appendChild(header);
+  col.appendChild(list);
+
+  return col;
+}
+
+function renderBoard(items) {
+  const board = document.getElementById("kanban-board");
+  board.innerHTML = "";
+
+  const counts = countByState(items);
+
+  STATES.forEach(state => {
+    board.appendChild(createColumn(state, items, counts));
+  });
+}
+
+
+async function loadBoard() {
+  const res = await fetch("/api/competencies/items");
+  const items = await res.json();
+  renderBoard(items);
+  populateMobileControls(items);
+}
+
+
+loadBoard();

assets/scripts/gallery-init.js

@@ -0,0 +1,255 @@
+document.addEventListener('DOMContentLoaded', () => {
+  if (typeof window.BiggerPicture !== 'function') {
+    console.error('[gallery-init] BiggerPicture not found. Check script path.');
+    return;
+  }
+
+  // 1) Wrap Org-exported images so they’re clickable
+  const imgs = document.querySelectorAll('.figure img, img.org-svg');
+  imgs.forEach((img) => {
+    if (img.closest('a')) return;                 // already wrapped
+    const a = document.createElement('a');
+    const href = img.currentSrc || img.src;
+    a.href = href;
+    a.dataset.img = href;                         // lets BP pre-size/raster slides
+    a.dataset.alt = img.alt || '';
+    const setDims = () => {
+      a.dataset.width  = img.naturalWidth  || img.width  || 1920;
+      a.dataset.height = img.naturalHeight || img.height || 1080;
+    };
+    if (img.complete) setDims(); else img.addEventListener('load', setDims);
+    img.style.cursor = 'zoom-in';
+    img.parentElement.insertBefore(a, img);
+    a.appendChild(img);
+  });
+
+  // 2) One global BP instance
+  const bp = BiggerPicture({ target: document.body });
+
+  // SVG pan/zoom handle
+  let activePanZoom = null;
+  const destroyPanZoom = () => { try { activePanZoom?.destroy(); } catch(_){} activePanZoom = null; };
+
+  // Simple rotate state (for non-SVG images)
+  let activeContainer = null;
+  let currentRotation = 0;
+  let rotateControls = null;
+
+  
+  // 3) Build galleries per content container
+  const containers = document.querySelectorAll('main, article, .content, body');
+  containers.forEach((container) => {
+    const links = Array.from(container.querySelectorAll('.figure a, a:has(img.org-svg)'));
+    if (!links.length) return;
+
+    // Start the lightbox on click
+    links.forEach((link, index) => {
+      link.addEventListener('click', (e) => {
+        e.preventDefault();
+        document.querySelectorAll(".theme-toggle").forEach(el => {
+          el.classList.add("hidden");
+        });
+
+        bp.open({
+          // IMPORTANT: pass the anchor ELEMENTS, not custom objects
+          items: links,
+          el: link,
+          caption: (el) => el.querySelector('img')?.alt || el.title || '',
+          maxZoom: 40, // for raster images (PNG/JPG); SVG handled separately
+
+          // Fade-out polish + cleanup
+          onClose(containerEl) {
+            destroyPanZoom();
+            teardownRotation();
+            if (containerEl) containerEl.classList.add('bp-fadeout');
+            const themeToggle = document.querySelector(".theme-toggle");
+            if (themeToggle) {
+              themeToggle.classList.remove("hidden");
+            }
+          },
+
+          // Called once after open and on every slide change
+          onOpen(containerEl)  { setupRotation(containerEl); enhanceSVG(containerEl); },
+          onUpdate(containerEl){ setupRotation(containerEl); enhanceSVG(containerEl); }
+        });
+      });
+    });
+  });
+
+  // 4) Simple rotate buttons for raster images
+  function ensureRotateControls() {
+    if (rotateControls) return rotateControls;
+
+    const wrapper = document.createElement('div');
+    wrapper.className = 'bp-rotate-controls';
+    Object.assign(wrapper.style, {
+      position: 'fixed',
+      bottom: '1.5rem',
+      right: '1.5rem',
+      display: 'flex',
+      gap: '0.5rem',
+      zIndex: '9999',
+      pointerEvents: 'auto'
+    });
+
+    const mkBtn = (label, title) => {
+      const btn = document.createElement('button');
+      btn.type = 'button';
+      btn.textContent = label;
+      btn.title = title;
+      btn.setAttribute('aria-label', title);
+      Object.assign(btn.style, {
+        padding: '0.4rem 0.6rem',
+        borderRadius: '999px',
+        border: 'none',
+        fontSize: '1.2rem',
+        cursor: 'pointer',
+        background: 'rgba(30,30,30,0.8)',
+        color: '#fff'
+      });
+      return btn;
+    };
+
+    const left  = mkBtn('⟲', 'Rotate image 90° left');
+    const right = mkBtn('⟳', 'Rotate image 90° right');
+
+    left.addEventListener('click', (e) => {
+      e.stopPropagation();                // don’t close the lightbox
+      if (!activeContainer) return;
+      currentRotation = (currentRotation - 90 + 360) % 360;
+      applyRotation();
+    });
+
+    right.addEventListener('click', (e) => {
+      e.stopPropagation();
+      if (!activeContainer) return;
+      currentRotation = (currentRotation + 90) % 360;
+      applyRotation();
+    });
+
+    wrapper.append(left, right);
+    document.body.appendChild(wrapper);
+    rotateControls = wrapper;
+    return rotateControls;
+  }
+
+  function ensureRotateWrapper() {
+    if (!activeContainer) return null;
+
+    const imgRoot = activeContainer.querySelector('.bp-img');
+    if (!imgRoot) return null;
+
+    let imgEl = imgRoot.querySelector('img');
+    if (!imgEl) return null;
+
+    const src = (imgEl.currentSrc || imgEl.src || '').toLowerCase();
+    // We only rotate raster images; SVGs are handled via svg-pan-zoom
+    if (src.endsWith('.svg')) return null;
+
+    let wrapper = imgRoot.querySelector('.bp-rotate-wrapper');
+    if (!wrapper) {
+      wrapper = document.createElement('div');
+      wrapper.className = 'bp-rotate-wrapper';
+      wrapper.style.display = 'inline-block';
+      wrapper.style.transformOrigin = 'center center';
+
+      imgRoot.appendChild(wrapper);
+      wrapper.appendChild(imgEl);
+    } else if (!wrapper.contains(imgEl)) {
+      // Slide changed and BiggerPicture replaced the <img>
+      wrapper.innerHTML = '';
+      wrapper.appendChild(imgEl);
+    }
+
+    return wrapper;
+  }
+
+  function applyRotation() {
+    const wrapper = ensureRotateWrapper();
+    if (!wrapper) return;
+    wrapper.style.transform = `rotate(${currentRotation}deg)`;
+  }
+
+  function setupRotation(containerEl) {
+    activeContainer = containerEl;
+    currentRotation = 0;
+    const controls = ensureRotateControls();
+    controls.style.display = 'flex';
+    applyRotation();
+  }
+
+  function teardownRotation() {
+    activeContainer = null;
+    currentRotation = 0;
+    if (rotateControls) {
+      rotateControls.style.display = 'none';
+    }
+  }
+
+  
+  // 4) If current slide is an SVG, swap to inline + enable svg-pan-zoom
+  async function enhanceSVG(containerEl) {
+    try {
+      destroyPanZoom();
+
+      const imgEl = containerEl.querySelector('.bp-img img');
+      if (!imgEl) return;
+
+      const src = imgEl.currentSrc || imgEl.src || '';
+      const isSVG = src.toLowerCase().endsWith('.svg');
+      const htmlLayer = containerEl.querySelector('.bp-html');
+      if (!isSVG || !htmlLayer) {
+        // ensure any previous holder is removed and bitmap is visible
+        const old = htmlLayer?.querySelector('.bp-svg-holder');
+        if (old) old.remove();
+        imgEl.style.visibility = '';
+        return;
+      }
+
+      // Create/clear holder
+      let holder = htmlLayer.querySelector('.bp-svg-holder');
+      if (!holder) {
+        holder = document.createElement('div');
+        holder.className = 'bp-svg-holder';
+        holder.style.maxWidth = '95vw';
+        holder.style.maxHeight = '95vh';
+        htmlLayer.appendChild(holder);
+      }
+      holder.innerHTML = '';
+
+      // Hide the bitmap so only the inline SVG shows
+      imgEl.style.visibility = 'hidden';
+
+      // Inline the SVG
+      const res = await fetch(src, { cache: 'force-cache' });
+      const text = await res.text();
+      holder.innerHTML = text;
+
+      const svg = holder.querySelector('svg');
+      if (!svg) { imgEl.style.visibility = ''; return; }
+
+      svg.style.maxWidth  = '95vw';
+      svg.style.maxHeight = '95vh';
+      svg.style.display   = 'block';
+
+      if (typeof window.svgPanZoom === 'function') {
+        activePanZoom = svgPanZoom(svg, {
+          zoomEnabled: true,
+          controlIconsEnabled: true,
+          fit: true,
+          center: true,
+          minZoom: 0.05,
+          maxZoom: 400,          // effectively "unlimited"
+          zoomScaleSensitivity: 0.25,
+          dblClickZoomEnabled: true
+        });
+        // Keep wheel inside lightbox
+        holder.addEventListener('wheel', (e) => e.stopPropagation(), { passive: true });
+      } else {
+        console.warn('[gallery-init] svg-pan-zoom not loaded');
+      }
+    } catch (err) {
+      console.error('[gallery-init] SVG enhance failed:', err);
+    }
+  }
+});

assets/scripts/gallery-init.js~

@@ -0,0 +1,138 @@
+document.addEventListener('DOMContentLoaded', () => {
+  if (typeof window.BiggerPicture !== 'function') {
+    console.error('[gallery-init] BiggerPicture not found. Check script path.');
+    return;
+  }
+
+  // 1) Wrap Org-exported images so they’re clickable
+  const imgs = document.querySelectorAll('.figure img, img.org-svg');
+  imgs.forEach((img) => {
+    if (img.closest('a')) return;                 // already wrapped
+    const a = document.createElement('a');
+    const href = img.currentSrc || img.src;
+    a.href = href;
+    a.dataset.img = href;                         // lets BP pre-size/raster slides
+    a.dataset.alt = img.alt || '';
+    const setDims = () => {
+      a.dataset.width  = img.naturalWidth  || img.width  || 1920;
+      a.dataset.height = img.naturalHeight || img.height || 1080;
+    };
+    if (img.complete) setDims(); else img.addEventListener('load', setDims);
+    img.style.cursor = 'zoom-in';
+    img.parentElement.insertBefore(a, img);
+    a.appendChild(img);
+  });
+
+  // 2) One global BP instance
+  const bp = BiggerPicture({ target: document.body });
+
+  // SVG pan/zoom handle
+  let activePanZoom = null;
+  const destroyPanZoom = () => { try { activePanZoom?.destroy(); } catch(_){} activePanZoom = null; };
+
+  // 3) Build galleries per content container
+  const containers = document.querySelectorAll('main, article, .content, body');
+  containers.forEach((container) => {
+    const links = Array.from(container.querySelectorAll('.figure a, a:has(img.org-svg)'));
+    if (!links.length) return;
+
+    // Start the lightbox on click
+    links.forEach((link, index) => {
+      link.addEventListener('click', (e) => {
+        e.preventDefault();
+        document.querySelectorAll(".theme-toggle").forEach(el => {
+          el.classList.add("hidden");
+        });
+
+	
+        bp.open({
+          // IMPORTANT: pass the anchor ELEMENTS, not custom objects
+          items: links,
+          el: link,
+          caption: (el) => el.querySelector('img')?.alt || el.title || '',
+          maxZoom: 40, // for raster images (PNG/JPG); SVG handled separately
+
+          // Fade-out polish + cleanup
+          onClose(containerEl) {
+            destroyPanZoom();
+            if (containerEl) containerEl.classList.add('bp-fadeout');
+            const themeToggle = document.querySelector(".theme-toggle");
+            if (themeToggle) {
+              themeToggle.classList.remove("hidden");
+            }
+          },
+
+          // Called once after open and on every slide change
+          onOpen(containerEl)  { enhanceSVG(containerEl); },
+          onUpdate(containerEl){ enhanceSVG(containerEl); }
+        });
+      });
+    });
+  });
+
+  // 4) If current slide is an SVG, swap to inline + enable svg-pan-zoom
+  async function enhanceSVG(containerEl) {
+    try {
+      destroyPanZoom();
+
+      const imgEl = containerEl.querySelector('.bp-img img');
+      if (!imgEl) return;
+
+      const src = imgEl.currentSrc || imgEl.src || '';
+      const isSVG = src.toLowerCase().endsWith('.svg');
+      const htmlLayer = containerEl.querySelector('.bp-html');
+      if (!isSVG || !htmlLayer) {
+        // ensure any previous holder is removed and bitmap is visible
+        const old = htmlLayer?.querySelector('.bp-svg-holder');
+        if (old) old.remove();
+        imgEl.style.visibility = '';
+        return;
+      }
+
+      // Create/clear holder
+      let holder = htmlLayer.querySelector('.bp-svg-holder');
+      if (!holder) {
+        holder = document.createElement('div');
+        holder.className = 'bp-svg-holder';
+        holder.style.maxWidth = '95vw';
+        holder.style.maxHeight = '95vh';
+        htmlLayer.appendChild(holder);
+      }
+      holder.innerHTML = '';
+
+      // Hide the bitmap so only the inline SVG shows
+      imgEl.style.visibility = 'hidden';
+
+      // Inline the SVG
+      const res = await fetch(src, { cache: 'force-cache' });
+      const text = await res.text();
+      holder.innerHTML = text;
+
+      const svg = holder.querySelector('svg');
+      if (!svg) { imgEl.style.visibility = ''; return; }
+
+      svg.style.maxWidth  = '95vw';
+      svg.style.maxHeight = '95vh';
+      svg.style.display   = 'block';
+
+      if (typeof window.svgPanZoom === 'function') {
+        activePanZoom = svgPanZoom(svg, {
+          zoomEnabled: true,
+          controlIconsEnabled: true,
+          fit: true,
+          center: true,
+          minZoom: 0.05,
+          maxZoom: 400,          // effectively "unlimited"
+          zoomScaleSensitivity: 0.25,
+          dblClickZoomEnabled: true
+        });
+        // Keep wheel inside lightbox
+        holder.addEventListener('wheel', (e) => e.stopPropagation(), { passive: true });
+      } else {
+        console.warn('[gallery-init] svg-pan-zoom not loaded');
+      }
+    } catch (err) {
+      console.error('[gallery-init] SVG enhance failed:', err);
+    }
+  }
+});

assets/scripts/notes.js

@@ -0,0 +1,102 @@
+(function () {
+  const wall = document.getElementById("notes-wall");
+  const form = document.getElementById("notes-form");
+  const authorInput = document.getElementById("note-author");
+  const contentInput = document.getElementById("note-content");
+
+  if (!wall) return;
+
+  function escapeHtml(str) {
+    return str
+      .replace(/&/g, "&")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#039;");
+  }
+
+  function renderNote(note) {
+    const el = document.createElement("div");
+    el.className = "note";
+
+    el.innerHTML = `
+      <div class="note-meta">
+        <span class="note-author">${escapeHtml(note.author_name)}</span>
+        <time datetime="${note.created_at}">
+          ${new Date(note.created_at).toLocaleString()}
+        </time>
+      </div>
+      <div class="note-content">
+        ${escapeHtml(note.content).replace(/\n/g, "<br>")}
+      </div>
+    `;
+
+    return el;
+  }
+
+  async function loadNotes() {
+    wall.innerHTML = "<p>Loading notes…</p>";
+
+    try {
+      const res = await fetch("/api/notes");
+      if (!res.ok) throw new Error("Failed to fetch notes");
+
+      const notes = await res.json();
+      wall.innerHTML = "";
+
+      if (notes.length === 0) {
+        wall.innerHTML = "<p>No notes yet.</p>";
+        return;
+      }
+
+      notes.forEach(note => {
+        wall.appendChild(renderNote(note));
+      });
+    } catch (err) {
+      console.error(err);
+      wall.innerHTML = "<p>Could not load notes.</p>";
+    }
+  }
+
+  async function submitNote(e) {
+    e.preventDefault();
+
+    const author = authorInput.value.trim();
+    const content = contentInput.value.trim();
+
+    if (!author || !content) return;
+
+    form.querySelector("button").disabled = true;
+
+    try {
+      const res = await fetch("/api/notes", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          author_name: author,
+          content: content,
+        }),
+      });
+
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.detail || "Failed to post note");
+      }
+
+      contentInput.value = "";
+      await loadNotes();
+    } catch (err) {
+      alert(err.message);
+    } finally {
+      form.querySelector("button").disabled = false;
+    }
+  }
+
+  if (form) {
+    form.addEventListener("submit", submitNote);
+  }
+
+  loadNotes();
+})();

assets/scripts/script.js

@@ -94,6 +94,47 @@ document.addEventListener("DOMContentLoaded", () => {
 })();
 
 
+// Simple, timezone-safe if you pass UTC (…Z) in the datetime
+document.addEventListener('DOMContentLoaded', () => {
+  const els = document.querySelectorAll('time.countdown');
+  if (!els.length) return;
+
+  const plural = (n, w) => `${n} ${w}${n === 1 ? '' : 's'}`;
+
+  const render = (el) => {
+    const raw = el.getAttribute('datetime');
+    const label = el.dataset.label || '';
+    const target = new Date(raw);           // Prefer ISO like 2025-12-31T00:00:00Z
+    if (isNaN(target)) { el.textContent = '—'; return; }
+
+    const now = new Date();
+    let diff = target - now;
+
+    if (diff <= 0) {
+      el.textContent = `${label ? label + ' ' : ''}today`;
+      el.classList.add('expired');
+      return;
+    }
+
+    const d = Math.floor(diff / 86400000);  diff -= d * 86400000;
+    const h = Math.floor(diff / 3600000);   diff -= h * 3600000;
+    const m = Math.floor(diff / 60000);     diff -= m * 60000;
+    const s = Math.floor(diff / 1000);
+
+    const pieces = [];
+    if (d) pieces.push(plural(d, 'day'));
+    pieces.push(`${h}h ${m}m ${s}s`);
+
+    el.textContent = `${label ? label + ' in : ' : ''}${pieces.join(' ')}`;
+  };
+
+  const tick = () => els.forEach(render);
+  tick();
+  setInterval(tick, 1000); // update every second
+});
+
+
+
 /* Event listener for scrolling and changing the active label on the TOC */
 document.addEventListener("DOMContentLoaded", () => {
     const toc = document.querySelector("#text-table-of-contents");
@@ -182,3 +223,5 @@ document.addEventListener("DOMContentLoaded", () => {
 	history.pushState(null, "", `#${id}`);
     });
 });
+
+

assets/scripts/status-board.js~

@@ -0,0 +1,98 @@
+const STATES = [
+  { key: "completed",    label: "Completed" },
+  { key: "manager_review",  label: "Manager Review" },
+  { key: "in_progress",   label: "In Progress" },
+  { key: "not_started",    label: "Not Started" },
+  { key: "comments",    label: "Comments" }
+];
+
+let draggedItemId = null;
+
+function countByState(items) {
+  return items.reduce((acc, item) => {
+    acc[item.state] = (acc[item.state] || 0) + 1;
+    return acc;
+  }, {});
+}
+
+function createCard(item) {
+  const card = document.createElement("div");
+  card.className = "kanban-card";
+  card.draggable = true;
+  card.dataset.id = item.id;
+  card.textContent = item.title;
+
+  card.addEventListener("dragstart", () => {
+    draggedItemId = item.id;
+    card.classList.add("dragging");
+  });
+
+  card.addEventListener("dragend", () => {
+    draggedItemId = null;
+    card.classList.remove("dragging");
+  });
+
+  return card;
+}
+
+function createColumn(state, items, counts) {
+  const col = document.createElement("div");
+  col.className = "kanban-column";
+  col.dataset.state = state.key;
+
+  const header = document.createElement("h3");
+  header.innerHTML = `
+  <span class="kanban-title">${state.label}</span>
+  <span class="kanban-count">${counts[state.key] || 0}</span>
+`;
+  
+  const list = document.createElement("div");
+  list.className = "kanban-list";
+
+  list.addEventListener("dragover", e => e.preventDefault());
+
+  list.addEventListener("drop", async () => {
+    if (!draggedItemId) return;
+
+    const res = await fetch(`/api/competencies/items/${draggedItemId}/state`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ state: state.key })
+    });
+
+    if (res.ok) {
+      loadBoard(); // simple & safe re-render
+    } else {
+      alert("Failed to update state");
+    }
+  });
+
+  items
+    .filter(i => i.state === state.key)
+    .forEach(i => list.appendChild(createCard(i)));
+
+  col.appendChild(header);
+  col.appendChild(list);
+
+  return col;
+}
+
+function renderBoard(items) {
+  const board = document.getElementById("kanban-board");
+  board.innerHTML = "";
+
+  const counts = countByState(items);
+
+  STATES.forEach(state => {
+    board.appendChild(createColumn(state, items, counts));
+  });
+}
+
+
+async function loadBoard() {
+  const res = await fetch("/api/competencies/items");
+  const items = await res.json();
+  renderBoard(items);
+}
+
+loadBoard();