jskelet 0.4.0 → 0.4.2

package/docs/04-render-ve-sablonlar.md

@@ -70,8 +70,34 @@ controller data → import edilmiş render(data, helpers) → HTML
 | Yerleşikler | `Link`, `Image`, `Icon`, `CsrfField`, `PreloadImage` |
 
 İfade dili kasıtlı olarak dardır (erişim, karşılaştırma, ternary, `.length`).
-Atama ve rastgele fonksiyon çağrısı yok — mantık controller veya JS bileşende
-kalır.
+Atama, object literal ve rastgele fonksiyon çağrısı yok — mantık controller
+veya JS bileşende kalır.
+
+#### Şablon mu, bileşen mi?
+
+EJS’den geçerken sınırı erken çizmek işe yarar:
+
+| Burada kalsın (`.jsk`) | JS bileşene taşı |
+| --- | --- |
+| Metin, koşul, liste, prop bağlama | Fonksiyon çağrısı, nesne üretimi, biçimlendirme |
+| Yerleşik etiketler (`Link`, `Image`, …) | Birden fazla yardımcıdan HTML birleştirme |
+| Controller’dan gelen hazır veri | Upstream / hata ayırt eden UI (`LoadErrorState`) |
+
+Şablonda `format(x)` veya `{ a: 1 }` yazılamıyorsa bu bir eksik değil: o iş
+`views/components/*.js` veya controller’ındır. Karmaşık sayfalar bileşene
+kaçıyorsa ifade dilini genişletmek yerine bileşen sınırını net tutmak tercih
+edilir.
+
+### Editör desteği
+
+Repo içinde `extensions/vscode-jsk` VS Code / Cursor uzantısı vardır: sözdizimi
+renklendirme, dil yapılandırması ve snippet'ler. Yerel kurulum:
+
+```bash
+code --install-extension extensions/vscode-jsk
+```
+
+Ayrıntılar uzantı README'sinde.
 
 ### EJS ile birlikte yaşam
 
@@ -243,13 +269,18 @@ Kurallar:
 
 - Tarama özyinelemelidir; alt dizinler de kapsanır.
 - `default` export'lar yok sayılır — yalnızca named export'lar kaydedilir.
+- Compile-time bilinen bileşen listesi **dosya adından değil**, kaynak
+  metindeki named export'lardan okunur. `ui.js` içindeki `sectionHead` →
+  şablonda `<SectionHead />` (runtime zaten camelCase export'a PascalCase
+  alias ekler). Dosya adına göre stub re-export eklemeye gerek yoktur.
 - `loader.js` ve `index.js` bileşen dosyası sayılmaz.
 - `views/components/index.js` varsa **barrel** olarak, en düşük öncelikle en
   önce yüklenir. Tek amacı `lib/` yeniden ihraçlarını şablon local'i yapmak;
   bileşenlerin kendi dosyaları sonradan gelip sessizce üzerine yazar.
-- Aynı ad iki farklı bileşen dosyasında tanımlıysa uyarı basılır ve **ikincisi
-  kazanır**: `[components] 'card' is defined twice: a.js and b.js — the second
-  one wins.`
+- Aynı ad (veya aynı PascalCase etiket) iki farklı bileşen dosyasında
+  tanımlıysa **uyarı değil hata**: build ve sunucu açılışı
+  `Component 'card' is defined twice: …` ile durur. Barrel üzerine yazmak
+  bilinçli istisnadır.
 - `views/components` dizini yoksa bileşen kaydı boş kalır; bileşen kullanmayan
   bir proje de çalışır.
 

package/docs/06-cache.md

@@ -380,6 +380,68 @@ export async function apiGet(path) {
 }
 ```
 
+### Loader sözleşmesi: boş liste ≠ hata
+
+`catch → []` (veya `null`) ile yutulan bir upstream hatası, yanlış mapping ile
+aynı görünür: boş UI. Rate limit ve geçici hatalar logda doğru yönde
+işaretlense bile ziyaretçi “veri yok” sanır. Widget loader’ları sessiz
+`[]`’ye gömülmek yerine sonucu ayırsın:
+
+```js
+/**
+ * @returns {Promise<{ items: object[], error: Error | null }>}
+ */
+export async function loadTickerItems() {
+  try {
+    const items = await apiGet("/ticker");
+    if (!items) {
+      return { items: [], error: new Error("Upstream returned no data") };
+    }
+    return { items, error: null };
+  } catch (error) {
+    return {
+      items: [],
+      error: error instanceof Error ? error : new Error(String(error)),
+    };
+  }
+}
+```
+
+Uygulama tarafında ortak bir `LoadErrorState` bileşeni (veya eşdeğeri) bu
+`error` alanını göstersin; her widget kendi boş hâline düşmesin:
+
+```js
+// views/components/load-error-state.js
+import { esc } from "jskelet/html";
+
+/**
+ * @param {{ message?: string, title?: string }} props
+ * @returns {string}
+ */
+export function LoadErrorState({ message, title = "Veri yüklenemedi" }) {
+  return `<div role="alert" data-load-error class="…">
+    <p>${esc(title)}</p>
+    ${message ? `<p>${esc(message)}</p>` : ""}
+  </div>`;
+}
+```
+
+```html
+{#if error}
+  <LoadErrorState :message="error.message" />
+{#else if items.length}
+  {#each items as item}
+    …
+  {/each}
+{#else}
+  <p>Kayıt yok</p>
+{/if}
+```
+
+Framework markaya özel UI taşımaz; `LoadErrorState` uygulama bileşenidir.
+Önemli olan sözleşme: `{ items, error }` (veya eşdeğeri) ve hata ile “gerçekten
+boş”un şablonda ayrı kolları.
+
 ### Geçici ve kalıcı hata ayrımı
 
 | Durum | Sayılır | Sonuç |

package/docs/en/01-getting-started.md

@@ -2,8 +2,8 @@
 
 This document explains how to get JSkelet running from scratch: installing the
 package, scaffolding the skeleton with `jskelet init`, writing your first route
-and your first island, what the resulting directory layout means, and the CLI's
-four commands. By the end you will have a page in the browser that is rendered
+and your first island, what the resulting directory layout means, and the CLI
+commands. By the end you will have a page in the browser that is rendered
 on the server, cached, and whose island hydrates on visibility. For the
 *reasons* behind the decisions see
 [02-architecture.md](./02-architecture.md), and for the full reference of every
@@ -58,21 +58,24 @@ what is missing and prints the number of skipped files as a warning. The goal is
 to skip the "I installed it but nothing works" stage entirely — `jskelet dev`
 runs right afterwards.
 
-The files it creates:
+The files it creates (feature-first + `.jsk`):
 
 ```
-jskelet.config.mjs          config: brand, preconnect, cache(), hooks
-routes/10-pages.mjs         the "/" route
-views/pages/home.ejs        home page template
-views/pages/not-found.ejs   404 template
-views/components/button.js  example component (a function returning an HTML string)
-client/entries/main.js      island bootstrap
-client/islands/counter.js   example island
-styles/globals.css          Tailwind entry + @source directives
-jsconfig.json               checkJs + the "@/*" alias
-.gitignore                  node_modules/, .jskelet/, public/assets/, .env
+jskelet.config.mjs                       config: brand, preconnect, cache(), hooks
+features/home/index.js                   the "/" route
+features/home/views/pages/home.jsk       home page template
+features/home/views/components/button.js example component (<Button />)
+features/home/client/counter.js          example island
+features/home/server/.gitkeep
+views/pages/not-found.jsk                app-wide 404
+client/entries/main.js                   island bootstrap
+styles/globals.css                       Tailwind entry + @source directives
+jsconfig.json                            checkJs + the "@/*" alias
+.gitignore                               node_modules/, .jskelet/, public/assets/, .env
 ```
 
+To grow: `npx jskelet generate feature <name>` (or `page` / `island`).
+
 Then:
 
 ```bash
@@ -92,44 +95,44 @@ None of the directory names are fixed; all of them can be overridden via
 
 | Directory | Default | Contents |
 | --- | --- | --- |
-| `views` | `views` | EJS layout, pages and components |
+| `views` | `views` | App-wide layout, pages and components |
+| `features` | `features` | Feature slices (`<name>/{server,views,client}`) |
+| `shared` | `shared` | Cross-feature server/views/client |
 | `public` | `public` | Static files; build output is written here too |
 | `client` | `client` | Island runtime sources and entries |
-| `routes` | `routes` | Route modules |
+| `routes` | `routes` | Route modules (loaded before features) |
 | `styles` | `styles/globals.css` | Tailwind/PostCSS entry **file** |
-| `generated` | `.jskelet` | Intermediate build output: `manifest.json`, `metafile.json`, `images.json` |
+| `generated` | `.jskelet` | Intermediate build output: `manifest.json`, `metafile.json`, `images.json`, `templates/` |
 
 In addition to these the framework always derives two paths and accepts no
 separate setting for them: `public/assets` (hashed build output) and
 `public/fonts` (self-hosted fonts).
 
-A typical project:
+A typical project (close to what `jskelet init` writes):
 
 ```
 my-site/
 ├── jskelet.config.mjs
 ├── jsconfig.json
-├── routes/
-│   ├── 10-pages.mjs
-│   └── 90-catch-all.mjs
+├── features/
+│   └── home/
+│       ├── index.js
+│       ├── server/
+│       ├── views/
+│       │   ├── pages/home.jsk
+│       │   └── components/button.js
+│       └── client/counter.js
 ├── views/
-│   ├── layout.ejs
-│   ├── pages/
-│   │   ├── home.ejs
-│   │   └── not-found.ejs
-│   └── components/
-│       └── card.js
+│   └── pages/not-found.jsk
 ├── client/
-│   ├── entries/
-│   │   └── main.js
-│   └── islands/
-│       └── counter.js
+│   └── entries/main.js
 ├── styles/
 │   └── globals.css
 ├── public/
 │   └── (static files; build → public/assets)
 └── .jskelet/
-    └── manifest.json
+    ├── manifest.json
+    └── templates/
 ```
 
 ## Your first route
@@ -140,7 +143,7 @@ a default export or a named export called `register`, with the signature
 `(app, api)`.
 
 ```js
-// routes/10-pages.mjs
+// features/home/index.js
 export default function register(app, { route }) {
   app.get(
     "/",
@@ -148,7 +151,7 @@ export default function register(app, { route }) {
       async () => ({
         view: "pages/home",
         metadata: { title: "Home" },
-        data: { heading: "JSkelet is running", items: ["One", "Two"] },
+        data: { message: "JSkelet is running" },
       }),
       { revalidate: 60 },
     ),
@@ -163,25 +166,26 @@ HTML cache, the notFound/redirect control flow, compression and the
 `X-JSkelet-Cache` header all come from it. The controller's only job is to
 return a page definition.
 
-The `10-` prefix in the file name determines the load order. Because `routes/`
-is scanned alphabetically, you should put catch-all routes such as `/:slug` in a
-file with a higher number; otherwise `/about` will be mistaken for a slug.
-Details: [03-routing.md](./03-routing.md).
+If you use `routes/`, the `10-` prefix in the file name determines load order;
+put catch-alls such as `/:slug` in a higher-numbered file. Feature `index.js`
+files are appended alphabetically after the `routes/` scan. Details:
+[03-routing.md](./03-routing.md).
 
-The template side is plain EJS:
+The template side is `.jsk` (compiled at build time):
 
-```ejs
-<%# views/pages/home.ejs %>
+```html
+{# features/home/views/pages/home.jsk #}
 <section class="wrapper">
-  <h1 class="text-3xl font-bold"><%= heading %></h1>
-  <%- list({ items }) %>
-  <div data-island="counter" data-island-props='{"start":5}'></div>
+  <h1>{{ metadata.title }}</h1>
+  <p>{{ message }}</p>
+  <Button text="Example component" />
+  <div data-island="counter" data-island-props='{"start":0}'></div>
 </section>
 ```
 
-Here `list` is a function defined in `views/components/list.js` and it has not
-been imported: every named export under `views/components/**` automatically
-becomes a template local ([04-rendering.md](./04-rendering.md)).
+`Button` comes from the `button` named export in
+`features/home/views/components/button.js` — PascalCase tag, no import
+([04-rendering.md](./04-rendering.md)).
 
 ## Your first island
 
@@ -199,7 +203,7 @@ carried as JSON inside `data-island-props`.
 `mount(element, props)`.
 
 ```js
-// client/islands/counter.js
+// features/home/client/counter.js
 /**
  * @param {HTMLElement} element
  * @param {{ start?: number }} props
@@ -231,7 +235,7 @@ import and starts the runtime.
 import { registerAll, start } from "jskelet/client";
 
 registerAll({
-  counter: () => import("../islands/counter.js"),
+  counter: () => import("../../features/home/client/counter.js"),
 });
 
 start();
@@ -245,7 +249,7 @@ runtime API are in [05-islands.md](./05-islands.md).
 
 ## CLI commands
 
-`bin/jskelet.mjs` offers four subcommands. Each runs in a separate Node process;
+`bin/jskelet.mjs` offers these subcommands. Each runs in a separate Node process;
 the reason is that `dev` manages two long-lived processes and the server needs
 ESM resolve hooks (`--import`) at process start.
 
@@ -254,7 +258,8 @@ ESM resolve hooks (`--import`) at process start.
 | `jskelet dev` | Build watch + server, in a single terminal. Live reload, CSS hot-swap, dev overlay. `NODE_ENV=development`. |
 | `jskelet build` | One-shot prod build: fonts → icon sprite → CSS → client JS → images → manifest → precompress. `production` if `NODE_ENV` is not given. |
 | `jskelet start` | Prod server. If there is no build output it produces it first. `production` if `NODE_ENV` is not given. |
-| `jskelet init` | Installs a minimal skeleton into the current directory; leaves existing files alone. |
+| `jskelet init` | Installs a feature-first `.jsk` skeleton into the current directory; leaves existing files alone. |
+| `jskelet generate` | Scaffolds a `feature` / `page` / `island`. |
 
 An unknown command, or a call with no arguments, prints the usage text.
 

package/docs/en/04-rendering.md

@@ -71,8 +71,34 @@ controller data → imported render(data, helpers) → HTML
 | Built-ins | `Link`, `Image`, `Icon`, `CsrfField`, `PreloadImage` |
 
 The expression language is intentionally small (access, compare, ternary,
-`.length`). No assignments or arbitrary calls — keep logic in controllers or JS
-components.
+`.length`). No assignments, object literals, or arbitrary calls — keep logic in
+controllers or JS components.
+
+#### Template or component?
+
+When moving off EJS, draw the line early:
+
+| Stay in `.jsk` | Move to a JS component |
+| --- | --- |
+| Text, conditionals, lists, prop binding | Function calls, object construction, formatting |
+| Built-in tags (`Link`, `Image`, …) | Composing HTML from several helpers |
+| Ready-made data from the controller | Upstream / error-aware UI (`LoadErrorState`) |
+
+If the template cannot write `format(x)` or `{ a: 1 }`, that is intentional: the
+work belongs in `views/components/*.js` or the controller. Prefer a clear
+component boundary over widening the expression language when complex pages
+“escape” into JS.
+
+### Editor support
+
+`extensions/vscode-jsk` is a VS Code / Cursor extension in this repo: syntax
+highlighting, language configuration, and snippets. Local install:
+
+```bash
+code --install-extension extensions/vscode-jsk
+```
+
+See the extension README for details.
 
 ### Coexistence with EJS
 
@@ -244,14 +270,20 @@ Rules:
 
 - The scan is recursive; subdirectories are covered too.
 - `default` exports are ignored — only named exports are registered.
+- The compile-time known-component set is read from **named exports in the
+  source**, not from the file basename. `sectionHead` in `ui.js` →
+  `<SectionHead />` in the template (runtime already adds a PascalCase alias
+  for camelCase exports). You do not need a stub re-export named after the
+  file.
 - `loader.js` and `index.js` do not count as component files.
 - If `views/components/index.js` exists it is loaded first as a **barrel**,
   with the lowest priority. Its only purpose is to turn `lib/` re-exports into
   template locals; the components' own files come later and silently overwrite
   it.
-- If the same name is defined in two different component files a warning is
-  printed and **the second one wins**: `[components] 'card' is defined twice:
-  a.js and b.js — the second one wins.`
+- If the same name (or the same PascalCase tag) is defined in two different
+  component files, that is an **error, not a warning**: build and server
+  startup stop with `Component 'card' is defined twice: …`. Overwriting the
+  barrel is the deliberate exception.
 - If the `views/components` directory does not exist the component registry
   stays empty; a project that uses no components works fine too.
 

package/docs/en/06-caching.md

@@ -390,6 +390,68 @@ export async function apiGet(path) {
 }
 ```
 
+### Loader contract: empty list ≠ error
+
+Swallowing an upstream failure with `catch → []` (or `null`) looks the same as
+a wrong mapping: empty UI. Even when rate limits are logged correctly, the
+visitor sees “no data”. Widget loaders should separate the result instead of
+burying a silent `[]`:
+
+```js
+/**
+ * @returns {Promise<{ items: object[], error: Error | null }>}
+ */
+export async function loadTickerItems() {
+  try {
+    const items = await apiGet("/ticker");
+    if (!items) {
+      return { items: [], error: new Error("Upstream returned no data") };
+    }
+    return { items, error: null };
+  } catch (error) {
+    return {
+      items: [],
+      error: error instanceof Error ? error : new Error(String(error)),
+    };
+  }
+}
+```
+
+An app-level shared `LoadErrorState` (or equivalent) should render that `error`
+field so each widget does not fall back to its own empty state:
+
+```js
+// views/components/load-error-state.js
+import { esc } from "jskelet/html";
+
+/**
+ * @param {{ message?: string, title?: string }} props
+ * @returns {string}
+ */
+export function LoadErrorState({ message, title = "Could not load data" }) {
+  return `<div role="alert" data-load-error class="…">
+    <p>${esc(title)}</p>
+    ${message ? `<p>${esc(message)}</p>` : ""}
+  </div>`;
+}
+```
+
+```html
+{#if error}
+  <LoadErrorState :message="error.message" />
+{#else if items.length}
+  {#each items as item}
+    …
+  {/each}
+{#else}
+  <p>No records</p>
+{/if}
+```
+
+The framework does not ship brand-specific UI; `LoadErrorState` is an
+application component. What matters is the contract: `{ items, error }` (or
+equivalent) and separate template branches for failure vs truly empty.
+
 ### Distinguishing transient and permanent failures
 
 | State | Counts as | Result |
@@ -778,77 +840,77 @@ Two more diagnostic surfaces:
 
 The full list of settings: [07-configuration.md](./07-configuration.md).
 
-## The admin panel
-
-Instead of hand-writing the `getHtmlCacheEntries()` / `getRedisStatus()`
-endpoints above, the framework ships a panel. It is deliberately separate from
-the dev overlay: the overlay only exists while `NODE_ENV=development`, while the
-panel does not look at the environment — "why is this page stale", "did the
-webhook purge land", "is Redis actually connected" are production questions.
-
-The panel is enabled with top-level `admin()` (not inside `cache()`) at
-`/_jskelet/admin`, with Overview, Cache, Routes, Views, Logs and System pages.
-The Cache page carries the same operations as the former single-page panel.
-
-```js
-// jskelet.config.mjs
-export default {
-  admin() {
-    return {
-      enabled: process.env.JSKELET_ADMIN === "1",
-      allowIps: ["10.0.0.0/8"], // empty = no IP restriction
-      blockBots: true,
-    };
-  },
-  cache() {
-    return {
-      html: { "/news/:slug": 300 },
-    };
-  },
-};
-```
-
-Without `enabled` **nothing is mounted**: the path does not exist, the module is
-never loaded and it costs the production process nothing. The environment
-variable (`JSKELET_ADMIN=1`) overrides the config, because the panel is
-usually opened once during an incident and editing the config file and
-redeploying is the last thing you want at that moment.
-
-When the panel is on, the server log prints the password in an `ADMIN` box at
-`http://localhost:3000/_jskelet/admin`.
-
-### Access and hardening
-
-- **The password is regenerated on every process start** (32 hex characters) and
-  only ever appears in the log. There is no persistent secret to leak.
-- **The password is not accepted in the query string.**
-- **`allowIps`** (exact IP or CIDR), when set, returns `404` for every request
-  outside the list — including the login page.
-- **`blockBots`** (default `true`) rejects known crawler UAs with `404`.
-- **Three failed attempts ban the IP for 24 hours** (`banAttempts`, `banHours`).
-- **Banned and unauthorised requests get a `404`.**
-- **Nothing is indexable:** `X-Robots-Tag`, `Cache-Control: no-store`,
-  `Referrer-Policy: no-referrer`; exempt from prewarming and navigation speculation.
-- Actions require an `X-JSkelet-Admin` header — the panel's own CSRF brake.
-- Sessions and ban counters live in process memory.
-
-### What the panel shows
-
-| Area | Contents |
-| --- | --- |
-| Overview | HTML/data/Redis/prewarm cards and upstream limiter summary |
-| Cache | Shared tier, Cloudflare, actions, entry list (former panel) |
-| Routes | Express path/method inventory, route modules, last-request summary |
-| Views | Template inventory under `views/` |
-| Logs | Live SSE queue with method/status/cache/kind/path and text filters |
-| System | Host RAM / disk |
-
-The list is **filtered by key** and the filter runs on the server: a data cache
-can hold tens of thousands of keys. At most 500 rows come back per request and
-the counter in the heading says how many matches were cut. HTML bodies and
-cached values are **never returned** — the panel's job is to show state, not to
-export content.
-
+## The admin panel
+
+Instead of hand-writing the `getHtmlCacheEntries()` / `getRedisStatus()`
+endpoints above, the framework ships a panel. It is deliberately separate from
+the dev overlay: the overlay only exists while `NODE_ENV=development`, while the
+panel does not look at the environment — "why is this page stale", "did the
+webhook purge land", "is Redis actually connected" are production questions.
+
+The panel is enabled with top-level `admin()` (not inside `cache()`) at
+`/_jskelet/admin`, with Overview, Cache, Routes, Views, Logs and System pages.
+The Cache page carries the same operations as the former single-page panel.
+
+```js
+// jskelet.config.mjs
+export default {
+  admin() {
+    return {
+      enabled: process.env.JSKELET_ADMIN === "1",
+      allowIps: ["10.0.0.0/8"], // empty = no IP restriction
+      blockBots: true,
+    };
+  },
+  cache() {
+    return {
+      html: { "/news/:slug": 300 },
+    };
+  },
+};
+```
+
+Without `enabled` **nothing is mounted**: the path does not exist, the module is
+never loaded and it costs the production process nothing. The environment
+variable (`JSKELET_ADMIN=1`) overrides the config, because the panel is
+usually opened once during an incident and editing the config file and
+redeploying is the last thing you want at that moment.
+
+When the panel is on, the server log prints the password in an `ADMIN` box at
+`http://localhost:3000/_jskelet/admin`.
+
+### Access and hardening
+
+- **The password is regenerated on every process start** (32 hex characters) and
+  only ever appears in the log. There is no persistent secret to leak.
+- **The password is not accepted in the query string.**
+- **`allowIps`** (exact IP or CIDR), when set, returns `404` for every request
+  outside the list — including the login page.
+- **`blockBots`** (default `true`) rejects known crawler UAs with `404`.
+- **Three failed attempts ban the IP for 24 hours** (`banAttempts`, `banHours`).
+- **Banned and unauthorised requests get a `404`.**
+- **Nothing is indexable:** `X-Robots-Tag`, `Cache-Control: no-store`,
+  `Referrer-Policy: no-referrer`; exempt from prewarming and navigation speculation.
+- Actions require an `X-JSkelet-Admin` header — the panel's own CSRF brake.
+- Sessions and ban counters live in process memory.
+
+### What the panel shows
+
+| Area | Contents |
+| --- | --- |
+| Overview | HTML/data/Redis/prewarm cards and upstream limiter summary |
+| Cache | Shared tier, Cloudflare, actions, entry list (former panel) |
+| Routes | Express path/method inventory, route modules, last-request summary |
+| Views | Template inventory under `views/` |
+| Logs | Live SSE queue with method/status/cache/kind/path and text filters |
+| System | Host RAM / disk |
+
+The list is **filtered by key** and the filter runs on the server: a data cache
+can hold tens of thousands of keys. At most 500 rows come back per request and
+the counter in the heading says how many matches were cut. HTML bodies and
+cached values are **never returned** — the panel's job is to show state, not to
+export content.
+
 ### What you can do from it
 
 | Action | Equivalent call |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jskelet",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "A framework that feels like no framework: Express 5 + build-time .jsk (or EJS) SSR, vanilla JS islands, Tailwind v4 and an in-process HTML TTL cache.",
   "type": "module",
   "license": "MIT",

package/src/compile/index.js

@@ -11,5 +11,7 @@ export {
   discoverJskFiles,
   componentNameFromViewId,
   collectKnownComponents,
+  toComponentTag,
 } from "./resolve.js";
+export { scanNamedExports } from "./scan-exports.js";
 export { compileAll, compileSource, ensureTemplatesCompiled } from "./compile-all.js";