@bendyline/gezel-service 0.1.0 → 1.0.0

package/dist/handboek-content/whats-new/1.26223.md

@@ -0,0 +1,82 @@
+---
+id: whats-new/1.26223
+title: 1.26223 — 11 August 2026
+order: -26223
+summary: Measured model scores, per-model memory controls, editable Office documents, and much stricter rules about what a gezel may install.
+---
+
+# 1.26223 — 11 August 2026
+
+This is the first release with written release notes, so it covers everything since **1.26219** on 7 August. It is a big one: four days of work, and most of it is visible the moment you open the app.
+
+If you read only one thing: gezel now publishes **measured scores** for the models it ships, your gezellen are much more tightly fenced in about what they may install on your machine, and Word, PowerPoint, Excel and PDF files in a project can now be edited as ordinary text.
+
+## Model scores you can actually check
+
+Choosing a local model used to mean guessing. Now there is a scoreboard.
+
+The new **Model scorecard** in the Technical section of this Handboek lists every model we have tested and how many jobs it actually finished correctly — writing a small working program, fixing a bug from its symptoms, following a procedure and stopping when something is wrong, turning a pile of documents into one summary, and a set of everyday office and knowledge tasks. Each job is run three times on a real machine and checked by a program, not by an opinion. A companion article, **How we test models**, explains what was counted and what the numbers do not tell you.
+
+The first published set covers four models measured on an M4 Max: gemma4-e4b, gemma4-12b, gemma4-31b and ornith-9b, on both task sets. Alongside the pass counts you now also get speed, how much memory a model needed in practice, and a separate quality read from a judging pass.
+
+Two rules keep the board honest. A model that was only partly measured is **withheld** rather than shown with a flattering gap, and earlier rounds of testing are kept visible separately instead of being quietly overwritten.
+
+## Your gezellen are on a shorter leash
+
+A gezel that can install software is useful. A gezel that can install *anything, anywhere* is not something you should have to think about. This release closes that gap.
+
+- **Installing packages is now registry-only and tied to one project.** A gezel can ask for a published package by name and version, into a project that already exists, and nothing else. Names, versions and destinations are all checked before anything runs.
+- **Approving a command now approves that exact command.** Previously, approving a script meant approving the words in it. Now gezel takes a fingerprint of the actual files the command would read — the script, its wrapper, the files it imports — so an approval you gave yesterday cannot be reused tomorrow for a script whose contents have changed underneath it.
+- **Names are checked everywhere.** Gezel, project, session and document identifiers now go through one shared rule, applied on disk, in the schemas, and on every web request, so a hand-crafted name cannot walk out of the folder it belongs in.
+- **On Linux and macOS, gezel's home folder is now locked to your account** (`0700`). Other accounts on the same machine can no longer read your conversations or files.
+
+None of this changes anything you do day to day. It changes what happens when something goes wrong.
+
+## Word, PowerPoint, Excel and PDF files are editable now
+
+Open a project and select a `.docx`, `.pptx`, `.xlsx`, `.pdf` or `.html` file, and gezel shows you its contents as clean Markdown you can read and search. The original file stays exactly where it was.
+
+Editing is deliberately a second step. The imported text is read-only until you choose **Allow editing via markdown** from the file's menu, and the first time you do, gezel takes a copy of the untouched original and keeps it. It is opt-in because rewriting someone's PowerPoint should never be something that happens by accident.
+
+## Real control over local models and memory
+
+If you run models on your own machine, this is the release where the machine stops being a mystery.
+
+- **Set the context size per model.** A slider in each model manager, instead of one setting for everything.
+- **Set a memory budget**, decide whether a model may **spill into ordinary RAM** when it does not fit on the graphics card, and have models **unload themselves when idle** so a forgotten model stops holding your machine hostage.
+- **An emergency stop.** The engine pill now has a "stop everything" action that cancels every chat in flight, clears anything queued, and drops gezel back into reactive mode — one place to press when something has run away from you.
+- Behind those controls, gezel is better at fitting a model into the memory you actually have: it will trade parallel capacity down to two lanes when doing so buys a meaningfully larger context, rather than refusing or thrashing.
+
+## Threads that are easier to follow
+
+- **Thread titles are derived the same way everywhere.** The name you see in the sidebar, in search and in the thread list is now the same name, worked out once instead of three times slightly differently.
+- **Recent threads appear as pills** above the conversation, so hopping between the two or three things you have going takes one click and puts you back where you were looking. Threads that are working, or that hit an error, are shown first — you should not have to go hunting for the one that needs you.
+- **Terminal threads show their last command** in the list, so you can tell them apart at a glance.
+- Chat references are more compact, the file tree and sidebar behave more predictably, and the Handboek's own table of contents now collapses by section, with craftbooks grouped into shelves rather than one long list.
+
+## Connecting gezel to other things
+
+- **Codex CLI can now use your local models.** A setup card in Settings writes a dedicated profile for the OpenAI Codex command-line tool that points it at gezel, so a coding tool you already use can run against a model on your own machine.
+- **New GitHub connectors** bring pull requests, releases and wiki pages in as project material, alongside the existing Google Calendar connector. Connector output now lands in the project's artifacts, where the rest of your work lives.
+- **The OpenAI-compatible endpoint speaks the Responses API**, including streaming — so apps built against the newer OpenAI shape work against gezel without a translation layer of their own.
+- Four new Handboek articles document all of this for developers: the npm package map, writing scripts with the gezel SDK, building connected apps with the app SDK, and how we test models.
+
+## Catalog updates without an app update
+
+Gezel's descriptions of models, craftbooks and roles — the *gilde* content — can now be refreshed on its own, without waiting for a new version of the app. It checks about once a day, verifies what it downloads, and only switches over after confirming that everything that worked before still works.
+
+It is **off unless you turn it on**, under Settings → About → Catalog content, and it will never touch a machine that has been pointed at a local content folder.
+
+## Smaller things
+
+- Windows machines without a working CUDA setup no longer get probed for one.
+- The Nemotron model family is recognized under its aliases and given the right tool format.
+- Installing gezel from npm no longer runs any install-time scripts; a permission repair that used to happen at install time now happens once, lazily, the first time it is needed.
+- Refreshed underlying editor and content packages (squisq 2.7.1, gilde 0.1.21).
+- A large set of new automated tests covering everyday office work — meeting follow-ups, research briefs, document round-trips, and whether a gezel reaches for the right tool — so regressions in ordinary tasks get caught before you meet them.
+
+## Anything to do?
+
+No. Update when you are offered it. Your gezellen, projects, threads and files are ordinary files on your disk and are read as-is by the new version.
+
+If you run local models and have been fighting for memory, it is worth a visit to the model manager for the new per-model context and memory settings. And if you want to see which model to trust with what, start at the [Model scorecard](../technical/model-scorecard.md).

package/dist/handboek-content/whats-new/whats-new-index.md

@@ -0,0 +1,28 @@
+---
+id: whats-new-index
+title: What's new
+order: -999999
+summary: Every gezel release, in plain language — what changed and what it means for you.
+---
+
+# What's new
+
+Gezel changes often. This section is the running record of those changes, one article per release, newest first.
+
+## Recent releases
+
+::handboek-whats-new-list
+
+Each article is written for the person using gezel, not for the person who wrote the code. It says what is different now, what you can do that you could not do before, and what — if anything — you need to do about it. Where a change is only interesting to developers, it is marked as such so you can skip it.
+
+## How to read a version number
+
+A gezel version looks like **1.26223.47**. The middle part is the date: `26` is the year 2026, and `223` is the day of that year — so `26223` is 11 August 2026. The last part is the build number for that day. You can always tell how old your copy of gezel is by reading the middle number.
+
+Your installed version is shown in **Settings → About**.
+
+## Updating
+
+Packaged installs check for new releases on their own and offer the update when one is ready. Nothing in your work is touched by an update: your gezellen, projects, threads, memories and files all live in ordinary files on your disk, and a new version simply reads the same files.
+
+Separately from app releases, gezel can pick up new catalog content — model descriptions, craftbooks, role templates — without a full update. That is the **Catalog content** setting under Settings → About, and it is off unless you turn it on.

package/dist/handboek.d.ts

@@ -1,4 +1,4 @@
-import { Poppetje, ModelTier, CatalogKind, CatalogItemSummary, CatalogItemDetail, HandboekRenderMode, HandboekFigure, HandboekArea, HandboekToc, HandboekArticle } from '@bendyline/gezel';
+import { Poppetje, ModelTier, HandboekArea, CatalogKind, CatalogItemSummary, CatalogItemDetail, HandboekRenderMode, HandboekFigure, HandboekToc, HandboekArticle } from '@bendyline/gezel';
 
 /**
  * What the handboek engine may know about *this install* when rendering
@@ -37,6 +37,51 @@ interface HandboekDeviceInfo {
 /** Device info for `site`/`agent-less` contexts: nothing personal to tell. */
 declare const siteDeviceInfo: HandboekDeviceInfo;
 
+/** Area folder order — also the TOC order. */
+declare const HANDBOEK_AREAS: readonly HandboekArea[];
+declare const HANDBOEK_AREA_TITLES: Record<HandboekArea, string>;
+/**
+ * The `whats-new` section index. Excluded from its own release list, and
+ * the one article in that area whose `order` is not a negated calendar
+ * line — see `docs/handboek/README.md`.
+ */
+declare const WHATS_NEW_INDEX_ID = "whats-new-index";
+/** One release, as the `whats-new-list` macro renders it. */
+interface ReleaseNoteEntry {
+    /** Article id — link targets resolve ids directly in app and site. */
+    id: string;
+    title: string;
+    /** The tweet-sized line. Absent only if an author forgot one. */
+    summary?: string;
+}
+interface CuratedArticle {
+    id: string;
+    area: HandboekArea;
+    title: string;
+    order: number;
+    summary?: string;
+    /** Article body — squisq-flavored markdown, macros not yet expanded. */
+    body: string;
+    /** Per-block seconds override for video playback. */
+    defaultDuration?: number;
+    /** When false, the CLI static-site export skips the article. */
+    siteVisible: boolean;
+}
+/**
+ * Locate the shipped handboek content tree. Same probe-chain shape as
+ * `findBundledUi()` in bin/gezeld.ts: an env override for tests and
+ * operators, the tsup-copied `dist/handboek-content/` in built trees,
+ * and the repo `docs/handboek/` when running from source (vitest, tsx).
+ */
+declare function findHandboekContent(): string | null;
+/**
+ * Release-note articles, newest first. Release `order` is the negated
+ * calendar line (`1.26223` → `-26223`), so the area's own ascending sort
+ * already puts the newest release on top; this only drops the section
+ * index out of the list it introduces.
+ */
+declare function listReleaseNotes(articles: CuratedArticle[]): ReleaseNoteEntry[];
+
 /** The slice of CatalogService the handboek needs — stubbable in tests. */
 interface HandboekCatalog {
     list(kind: CatalogKind): Promise<CatalogItemSummary[]>;
@@ -46,6 +91,12 @@ interface MacroContext {
     mode: HandboekRenderMode;
     catalog: HandboekCatalog;
     device: HandboekDeviceInfo;
+    /**
+     * Release-note articles, newest first. Supplied by the engine from the
+     * curated tree rather than read here, so the `whats-new-list` macro
+     * stays a pure renderer and the tests can stub a release history.
+     */
+    releases: ReleaseNoteEntry[];
     /** Figures referenced by expanded markdown accumulate here. */
     figures: HandboekFigure[];
 }
@@ -73,30 +124,6 @@ declare function expandMacros(source: string, ctx: Omit<MacroContext, 'figures'>
 /** Parse `key=value key2="quoted value"` attribute syntax. */
 declare function parseAttrs(raw: string): Record<string, string>;
 
-/** Area folder order — also the TOC order. */
-declare const HANDBOEK_AREAS: readonly HandboekArea[];
-declare const HANDBOEK_AREA_TITLES: Record<HandboekArea, string>;
-interface CuratedArticle {
-    id: string;
-    area: HandboekArea;
-    title: string;
-    order: number;
-    summary?: string;
-    /** Article body — squisq-flavored markdown, macros not yet expanded. */
-    body: string;
-    /** Per-block seconds override for video playback. */
-    defaultDuration?: number;
-    /** When false, the CLI static-site export skips the article. */
-    siteVisible: boolean;
-}
-/**
- * Locate the shipped handboek content tree. Same probe-chain shape as
- * `findBundledUi()` in bin/gezeld.ts: an env override for tests and
- * operators, the tsup-copied `dist/handboek-content/` in built trees,
- * and the repo `docs/handboek/` when running from source (vitest, tsx).
- */
-declare function findHandboekContent(): string | null;
-
 interface HandboekEngineOptions {
     catalog: HandboekCatalog;
     device: HandboekDeviceInfo;
@@ -131,4 +158,4 @@ interface HandboekEngine {
  */
 declare function createHandboekEngine(opts: HandboekEngineOptions): HandboekEngine;
 
-export { type CuratedArticle, HANDBOEK_AREAS, HANDBOEK_AREA_TITLES, type HandboekArticleOptions, type HandboekCatalog, type HandboekDeviceInfo, type HandboekEngine, type HandboekEngineOptions, type HandboekGezelInfo, type HandboekHardwareInfo, type HandboekHardwareTier, type HandboekModelInfo, MACROS, createHandboekEngine, expandMacros, findHandboekContent, parseAttrs, siteDeviceInfo };
+export { type CuratedArticle, HANDBOEK_AREAS, HANDBOEK_AREA_TITLES, type HandboekArticleOptions, type HandboekCatalog, type HandboekDeviceInfo, type HandboekEngine, type HandboekEngineOptions, type HandboekGezelInfo, type HandboekHardwareInfo, type HandboekHardwareTier, type HandboekModelInfo, MACROS, type ReleaseNoteEntry, WHATS_NEW_INDEX_ID, createHandboekEngine, expandMacros, findHandboekContent, listReleaseNotes, parseAttrs, siteDeviceInfo };

package/dist/handboek.js

@@ -15,15 +15,18 @@ var HANDBOEK_AREAS = [
   "gezel-roles",
   "craftbooks",
   "project-types",
-  "technical"
+  "technical",
+  "whats-new"
 ];
 var HANDBOEK_AREA_TITLES = {
   conceptual: "Concepts",
   "gezel-roles": "Gezel Roles",
   craftbooks: "Craftbooks",
   "project-types": "Project Types",
-  technical: "Technical"
+  technical: "Technical",
+  "whats-new": "What's New"
 };
+var WHATS_NEW_INDEX_ID = "whats-new-index";
 function findHandboekContent() {
   const override = process.env.GEZEL_HANDBOEK_DIR?.trim();
   if (override) return existsSync(override) ? resolve(override) : null;
@@ -66,6 +69,9 @@ function loadCuratedArticles(contentDir) {
   out.sort((a, b) => a.area === b.area ? a.order - b.order : 0);
   return out;
 }
+function listReleaseNotes(articles) {
+  return articles.filter((a) => a.area === "whats-new" && a.id !== WHATS_NEW_INDEX_ID).sort((a, b) => a.order - b.order).map((a) => ({ id: a.id, title: a.title, summary: a.summary }));
+}
 function parseCuratedArticle(source, area, filename) {
   HandboekAreaSchema.parse(area);
   const { frontmatter, body } = splitFrontmatterBlock(source);
@@ -90,7 +96,7 @@ function titleFromBody(body, fallback) {
 }
 
 // src/handboek/generated.ts
-import { ROLES } from "@bendyline/gezel";
+import { CRAFTBOOK_ROLE_META, ROLES } from "@bendyline/gezel";
 function firstSentence(text) {
   const s = text.trim().split(/\.\s/)[0]?.replace(/\.$/, "").trim();
   return s ? `${s}.` : void 0;
@@ -115,12 +121,20 @@ async function listGeneratedSummaries(catalog) {
   });
   const craftbooks = (await catalog.list("craftbook-template")).map((s) => s.manifest).sort((a, b) => a.name.localeCompare(b.name));
   for (const book of craftbooks) {
+    const role = book.role ?? "general";
+    const roleIndex = CRAFTBOOK_ROLE_META.findIndex((item) => item.id === role);
+    const roleMeta = CRAFTBOOK_ROLE_META[roleIndex] ?? CRAFTBOOK_ROLE_META.at(-1);
     out.push({
       id: `craftbook/${book.id}`,
       area: "craftbooks",
       title: book.name,
       order: 10,
-      summary: firstSentence(book.description)
+      summary: firstSentence(book.description),
+      subcategory: {
+        id: roleMeta.id,
+        title: roleMeta.label,
+        order: roleIndex < 0 ? CRAFTBOOK_ROLE_META.length : roleIndex
+      }
     });
   }
   out.push({
@@ -245,6 +259,7 @@ import {
   describeProvenance,
   provenanceDifferences,
   resolveRoleId as resolveRoleId2,
+  scoreModel,
   toolsetGroupsForRole as toolsetGroupsForRole2
 } from "@bendyline/gezel";
 import { BUILTIN_TOOLSETS as BUILTIN_TOOLSETS2 } from "@bendyline/gezel-catalog";
@@ -599,8 +614,10 @@ var MACROS = {
   "installed-models": installedModels,
   "model-scorecard": modelScorecard,
   "project-type-composition": projectTypeComposition,
-  "suggested-work": suggestedWork
+  "suggested-work": suggestedWork,
+  "whats-new-list": whatsNewList
 };
+var WHATS_NEW_LIST_DEFAULT_LIMIT = 12;
 var DIRECTIVE_RE = /^::handboek-([a-z0-9-]+)(?:\{([^}]*)\})?\s*$/;
 async function expandMacros(source, ctx) {
   const figures = [];
@@ -904,6 +921,16 @@ async function craftbookList(attrs, ctx) {
   });
   return ["| Craftbook | What it does |", "| --- | --- |", ...rows].join("\n");
 }
+async function whatsNewList(attrs, ctx) {
+  const parsed = Number.parseInt(attrs.limit ?? "", 10);
+  const limit = Number.isFinite(parsed) && parsed > 0 ? parsed : WHATS_NEW_LIST_DEFAULT_LIMIT;
+  const releases = ctx.releases.slice(0, limit);
+  if (releases.length === 0) return "No releases have been written up yet.";
+  return releases.map((r) => {
+    const line = `- **[${r.title}](${r.id})**`;
+    return r.summary ? `${line} \u2014 ${r.summary}` : line;
+  }).join("\n");
+}
 async function deviceHardware(_attrs, ctx) {
   if (ctx.mode === "site") {
     return "Gezel classifies each device as tiny, small, medium, or large from the memory available to local models. Open this page in the app to see the current device.";
@@ -944,6 +971,8 @@ function renderScorecardMarkdown(dataset, suiteId, opts) {
     ].join("\n");
   }
   const lines = [];
+  const publishable = board.scores.filter((score) => score.unmeasuredScenarios.length === 0);
+  const withheld = board.scores.filter((score) => score.unmeasuredScenarios.length > 0);
   lines.push(
     `**${describeProvenance(
       board.run,
@@ -951,33 +980,75 @@ function renderScorecardMarkdown(dataset, suiteId, opts) {
     )}**`
   );
   lines.push("");
-  lines.push("| Model | Size | Tasks passed | Not measured |");
-  lines.push("| --- | --- | --- | --- |");
-  for (const score of board.scores) {
-    const discarded = score.discardedTrials > 0 ? `${score.discardedTrials} run${score.discardedTrials === 1 ? "" : "s"} lost to the machine` : "\u2014";
-    lines.push(
-      `| ${score.result.label} | ${score.result.parameterSize ?? score.result.tier} | ${score.claim} | ${discarded} |`
-    );
-  }
-  if (board.otherRunScores.length > 0) {
+  lines.push(...scoreTable(publishable));
+  if (withheld.length > 0) {
     lines.push("");
-    lines.push("Measured in an earlier round, so not directly comparable with the table above:");
+    lines.push("Not published \u2014 some tasks could not be measured on this round:");
     lines.push("");
-    lines.push("| Model | Tasks passed | Why it is listed apart |");
-    lines.push("| --- | --- | --- |");
-    for (const entry of board.otherRunScores) {
-      const why = provenanceDifferences(board.run, entry.run);
-      lines.push(
-        `| ${entry.result.label} | ${entry.claim} | ${why.length > 0 ? why.join(", ") : "earlier round"} |`
-      );
+    for (const score of withheld) {
+      lines.push(`- ${score.result.label}: ${score.unmeasuredScenarios.length} task(s) unmeasured`);
     }
   }
+  const priorRuns = dataset.runs.filter((run) => run.id !== board.run.id && run.suites.includes(suiteId)).slice(0, PRIOR_ROUNDS_SHOWN);
+  for (const run of priorRuns) {
+    const scores = dataset.results.filter((result) => result.runId === run.id && result.suiteId === suiteId).map((result) => scoreModel(result, run.provenance.count)).filter((score) => score.unmeasuredScenarios.length === 0).sort((a, b) => b.successes / b.attributableTrials - a.successes / a.attributableTrials);
+    if (scores.length === 0) continue;
+    const why = provenanceDifferences(board.run, run);
+    lines.push("");
+    lines.push(`### Earlier round \u2014 ${run.provenance.startedAt.slice(0, 10)}`);
+    lines.push("");
+    lines.push(
+      `**${describeProvenance(
+        run,
+        scores.map((s) => s.result.engine)
+      )}**${why.length > 0 ? ` \u2014 ${why.join(", ")}` : ""}`
+    );
+    lines.push("");
+    lines.push(...scoreTable(scores));
+  }
   if (opts.includeTaskCount) {
     lines.push("");
     lines.push(`Tasks in this set: ${board.scenarioIds.length}.`);
   }
   return lines.join("\n");
 }
+var PRIOR_ROUNDS_SHOWN = 2;
+function scoreTable(scores) {
+  const anySpeed = scores.some((score) => !!score.result.performance);
+  const anyRuntime = scores.some((score) => !!score.result.runtime);
+  const anyJudge = scores.some((score) => !!score.result.judge);
+  const cols = ["Model", "Size", "Tasks passed"];
+  if (anyJudge) cols.push("Quality");
+  if (anySpeed) cols.push("Reads at", "Writes at");
+  if (anyRuntime) cols.push("Context", "Memory used");
+  const rows = scores.map((score) => {
+    const cells = [
+      score.result.label,
+      score.result.parameterSize ?? score.result.tier,
+      score.claim
+    ];
+    if (anyJudge) {
+      const judge = score.result.judge;
+      cells.push(judge ? `${judge.meanScore}/10 (${judge.artifacts} pieces)` : "\u2014");
+    }
+    if (anySpeed) {
+      const perf = score.result.performance;
+      cells.push(
+        perf ? `${perf.prefillTokensPerSec.toLocaleString()} tok/s` : "\u2014",
+        perf ? `${perf.decodeTokensPerSec} tok/s` : "\u2014"
+      );
+    }
+    if (anyRuntime) {
+      const runtime = score.result.runtime;
+      cells.push(
+        runtime ? `${Math.round(runtime.contextTokens / 1024)}K` : "\u2014",
+        runtime ? `${(runtime.peakMemoryMb / 1024).toFixed(1)} GB` : "\u2014"
+      );
+    }
+    return `| ${cells.join(" | ")} |`;
+  });
+  return [`| ${cols.join(" | ")} |`, `| ${cols.map(() => "---").join(" | ")} |`, ...rows];
+}
 async function projectTypeComposition(attrs, ctx) {
   if (!attrs.id) return "";
   const detail = await ctx.catalog.get("project-type", attrs.id);
@@ -1076,7 +1147,8 @@ function createHandboekEngine(opts) {
             order: g.order,
             summary: g.summary,
             generated: true,
-            siteVisible: true
+            siteVisible: true,
+            subcategory: g.subcategory
           }))
         ].sort((a, b) => a.order - b.order || a.title.localeCompare(b.title));
         return { area, title: HANDBOEK_AREA_TITLES[area], entries };
@@ -1085,12 +1157,14 @@ function createHandboekEngine(opts) {
     },
     async article(id, articleOpts) {
       const mode = articleOpts?.mode ?? "app";
-      const curatedMatch = curated().find((a) => a.id === id);
+      const curatedArticles = curated();
+      const curatedMatch = curatedArticles.find((a) => a.id === id);
       if (curatedMatch) {
         const { markdown: markdown2, figures: figures2 } = await expandMacros(curatedMatch.body, {
           mode,
           catalog: opts.catalog,
-          device: opts.device
+          device: opts.device,
+          releases: listReleaseNotes(curatedArticles)
         });
         return {
           id,
@@ -1117,7 +1191,8 @@ function createHandboekEngine(opts) {
       const { markdown, figures } = await expandMacros(body, {
         mode,
         catalog: opts.catalog,
-        device: opts.device
+        device: opts.device,
+        releases: listReleaseNotes(curatedArticles)
       });
       return {
         id,
@@ -1210,9 +1285,11 @@ export {
   HANDBOEK_AREAS,
   HANDBOEK_AREA_TITLES,
   MACROS,
+  WHATS_NEW_INDEX_ID,
   createHandboekEngine,
   expandMacros,
   findHandboekContent,
+  listReleaseNotes,
   parseAttrs,
   siteDeviceInfo
 };