jskelet 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -27,6 +27,17 @@ one is listed under a **Breaking** heading.
 
 ### Added
 
+- VS Code / Cursor extension skeleton under `extensions/vscode-jsk`: `.jsk`
+  language id, TextMate highlighting (`{{ }}` / `{#if}` / `{#each}` /
+  components), language config, and snippets. Install from that folder or
+  launch **JSK: Extension** from the repo root. Bound attrs on HTML tags
+  (`:src="… + '/path'"`) highlight nested single-quoted strings.
+- Compile-time known components are discovered from **named exports** in
+  `views/components/**/*.js` (plus `.jsk` component files), not from the file
+  basename — so `<SectionHead />` resolves when `sectionHead` lives in
+  `ui.js` without a stub re-export. Docs cover the `.jsk` template-vs-component
+  boundary and a `{ items, error }` loader / `LoadErrorState` pattern so
+  upstream failures are not mistaken for empty data.
 - Build-time `.jsk` templates: declarative HTML-like syntax compiled to ESM
   render modules under `.jskelet/templates/` (no request-time parse, `eval`, or
   `new Function`). Coexists with EJS; compiled `.jsk` wins when both exist.
@@ -127,8 +138,14 @@ one is listed under a **Breaking** heading.
 
 ### Changed
 
+- Duplicate component named exports (or the same PascalCase tag in two files)
+  now **fail** at build and at server startup instead of warning and letting
+  the second definition win. Overwriting `components/index.js` barrel exports
+  remains allowed.
 - `examples/minimal` pages moved to `.jsk`; adds `features/demo` as a
   co-located route + view sample.
+- Marketing compare/FAQ copy no longer claims targeted invalidation is missing;
+  it points at `invalidateHtmlCache()` (and Redis pub/sub for multi-instance).
 
 - An adaptive per-host rate limit for upstream calls, `cache().upstream`. It sits
   in the `fetch` wrapper rather than in the prewarm pass, because what spends the

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/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.1",
   "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";

package/src/compile/resolve.js

@@ -7,6 +7,17 @@
 import fs from "node:fs";
 import path from "node:path";
 import { toPascalCase } from "./codegen.js";
+import { CompileError } from "./errors.js";
+import { scanNamedExports } from "./scan-exports.js";
+
+/**
+ * Runtime'ın camelCase → PascalCase alias'ı ile aynı kural.
+ * @param {string} name
+ * @returns {string}
+ */
+export function toComponentTag(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
 
 /**
  * @param {{ root: string, dirs: Record<string, string> }} config
@@ -106,6 +117,9 @@ export function componentNameFromViewId(viewId) {
  * Bilinen bileşen adları: JS named export'lar + derlenecek `.jsk` bileşenleri
  * + yerleşik etiketler.
  *
+ * JS tarafında dosya adı varsayılmaz; kaynak metinden `export` adları okunur.
+ * Aynı export (veya aynı PascalCase etiket) iki dosyada varsa derleme hatası.
+ *
  * @param {string[]} componentDirs
  * @param {Map<string, string>} jskFiles
  * @returns {Set<string>}
@@ -119,41 +133,76 @@ export function collectKnownComponents(componentDirs, jskFiles) {
     "PreloadImage",
   ]);
 
+  /** @type {Map<string, string>} export adı → göreli yol */
+  const byName = new Map();
+  /** @type {Map<string, string>} PascalCase etiket → göreli yol */
+  const byTag = new Map();
+
   for (const [viewId] of jskFiles) {
     const name = componentNameFromViewId(viewId);
-    if (name) known.add(name);
+    if (!name) continue;
+    known.add(name);
+    byTag.set(name, `${viewId}.jsk`);
   }
 
   for (const dir of componentDirs) {
-    collectJsComponentNames(dir, dir, known);
+    collectJsComponentNames(dir, known, byName, byTag);
   }
 
   return known;
 }
 
+/**
+ * @param {string} name
+ * @param {string} origin
+ * @param {Map<string, string>} byName
+ * @param {Map<string, string>} byTag
+ */
+function registerExportOrigin(name, origin, byName, byTag) {
+  const previousName = byName.get(name);
+  if (previousName && previousName !== origin) {
+    throw new CompileError(
+      `Component '${name}' is defined twice: ${previousName} and ${origin}`,
+    );
+  }
+  byName.set(name, origin);
+
+  const tag = toComponentTag(name);
+  const previousTag = byTag.get(tag);
+  if (previousTag && previousTag !== origin) {
+    throw new CompileError(
+      `Component '${tag}' is defined twice: ${previousTag} and ${origin}`,
+    );
+  }
+  byTag.set(tag, origin);
+}
+
 /**
  * @param {string} dir
- * @param {string} root
  * @param {Set<string>} out
+ * @param {Map<string, string>} byName
+ * @param {Map<string, string>} byTag
  */
-function collectJsComponentNames(dir, root, out) {
+function collectJsComponentNames(dir, out, byName, byTag) {
   if (!fs.existsSync(dir)) return;
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
-      collectJsComponentNames(full, root, out);
+      collectJsComponentNames(full, out, byName, byTag);
       continue;
     }
     if (!entry.name.endsWith(".js")) continue;
-    if (entry.name === "loader.js") continue;
-    // Dosya adından PascalCase tahmin — export adı dosya içinde olabilir;
-    // bilinmeyen bileşen uyarısını azaltmak için her iki biçimi ekle.
-    const base = entry.name.replace(/\.js$/, "");
-    if (base === "index") continue;
-    out.add(toPascalCase(base));
-    // camelCase export'lar da yaygın: `list` → List ve list
-    out.add(base);
-    const pascal = toPascalCase(base);
-    out.add(pascal.charAt(0).toLowerCase() + pascal.slice(1));
+    if (entry.name === "loader.js" || entry.name === "index.js") continue;
+
+    // Kimlik mutlak yol: çoklu kökte iki `list.js` aynı göreli ada sahip olabilir.
+    const origin = full.split(path.sep).join("/");
+    const source = fs.readFileSync(full, "utf8");
+    const exports = scanNamedExports(source);
+
+    for (const name of exports) {
+      registerExportOrigin(name, origin, byName, byTag);
+      out.add(name);
+      out.add(toComponentTag(name));
+    }
   }
 }

package/src/compile/scan-exports.js

@@ -0,0 +1,51 @@
+/**
+ * Kaynak metinden named export adlarını çıkarır — modülü çalıştırmadan.
+ * Compile-time bilinen bileşen listesi için; `default` yok sayılır.
+ */
+
+/**
+ * Yorumları kaba şekilde siler; string içindeki sahte eşleşmeler nadirdir.
+ * @param {string} source
+ * @returns {string}
+ */
+function stripComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+}
+
+/**
+ * `export { a, b as C, default as X }` listesinden dışa verilen adları toplar.
+ * @param {string} clause
+ * @param {Set<string>} out
+ */
+function addExportList(clause, out) {
+  for (const part of clause.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const bits = trimmed.split(/\s+as\s+/i);
+    const exported = (bits[1] ?? bits[0]).trim();
+    if (!exported || exported === "default") continue;
+    out.add(exported);
+  }
+}
+
+/**
+ * @param {string} source
+ * @returns {string[]}
+ */
+export function scanNamedExports(source) {
+  const text = stripComments(source);
+  /** @type {Set<string>} */
+  const names = new Set();
+
+  for (const match of text.matchAll(
+    /\bexport\s+(?:async\s+)?(?:function\*?|class|const|let|var)\s+([A-Za-z_$][\w$]*)/g,
+  )) {
+    names.add(match[1]);
+  }
+
+  for (const match of text.matchAll(/\bexport\s*\{([^}]+)\}/g)) {
+    addExportList(match[1], names);
+  }
+
+  return [...names];
+}

package/src/views/components/loader.js

@@ -60,21 +60,24 @@ async function loadDir(dir, components, origin) {
   ];
 
   for (const file of files) {
-    const relative = path.relative(dir, file).split(path.sep).join("/");
+    const isBarrel = path.basename(file) === BARREL;
+    // Kimlik mutlak yol — çoklu components kökünde göreli ad çakışmasın.
+    const fileId = isBarrel ? BARREL : file.split(path.sep).join("/");
     const module = await import(pathToFileURL(file).href);
 
     for (const [name, value] of Object.entries(module)) {
       if (name === "default") continue;
 
       const previous = origin.get(name);
-      if (previous && previous !== BARREL && previous !== relative) {
-        console.warn(
-          `[components] '${name}' is defined twice: ${previous} and ${relative} — the second one wins.`,
+      // Barrel üzerine yazmak bilinçli; iki gerçek bileşen dosyası çakışması hata.
+      if (previous && previous !== BARREL && previous !== fileId) {
+        throw new Error(
+          `[components] '${name}' is defined twice: ${previous} and ${fileId}`,
         );
       }
 
       components[name] = value;
-      origin.set(name, relative);
+      origin.set(name, fileId);
     }
   }
 }