@nuraly/lumenjs 0.1.3 → 0.2.0

package/dist/db/index.js

@@ -1,67 +1,223 @@
 import path from 'path';
 import fs from 'fs';
+import { createRequire } from 'module';
+import { AsyncLocalStorage } from 'async_hooks';
 import Database from 'better-sqlite3';
+const _require = createRequire(import.meta.url);
 import { getProjectDir } from './context.js';
-import { readProjectConfig } from '../dev-server/config.js';
+import { autoMigrate } from './auto-migrate.js';
+import { getRegisteredTables } from './table.js';
+import { autoSeed } from './seed.js';
+export { defineTable, getRegisteredTables } from './table.js';
+export { waitForSeed } from './seed.js';
+// ── Abstract async interface ───────────────────────────────────────────────
 export class LumenDb {
+    constructor() {
+        this.isPg = false;
+    }
+    /** Raw SQLite Database — only available in SQLite mode */
+    get raw() {
+        throw new Error('raw is only available in SQLite mode');
+    }
+}
+// ── SQLite implementation ─────────────────────────────────────────────────
+class LumenDbSqlite extends LumenDb {
     constructor(db) {
+        super();
         this.db = db;
+        this.isPg = false;
     }
-    /** SELECT multiple rows */
-    all(sql, ...params) {
+    async all(sql, ...params) {
         return this.db.prepare(sql).all(...params);
     }
-    /** SELECT single row */
-    get(sql, ...params) {
+    async get(sql, ...params) {
         return this.db.prepare(sql).get(...params);
     }
-    /** INSERT/UPDATE/DELETE */
-    run(sql, ...params) {
-        const result = this.db.prepare(sql).run(...params);
+    async run(sql, ...params) {
+        const stmt = this.db.prepare(sql);
+        // RETURNING clause → use .get() to capture the returned row's id
+        if (/\bRETURNING\b/i.test(sql)) {
+            const row = stmt.get(...params);
+            return { changes: 1, lastInsertRowid: row?.id ?? 0 };
+        }
+        const result = stmt.run(...params);
         return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
     }
-    /** Multi-statement DDL */
-    exec(sql) {
+    async exec(sql) {
         this.db.exec(sql);
     }
-    /** Access the underlying better-sqlite3 instance */
+    async withTransaction(fn) {
+        this.db.exec('BEGIN');
+        try {
+            const result = await fn();
+            this.db.exec('COMMIT');
+            return result;
+        }
+        catch (e) {
+            try {
+                this.db.exec('ROLLBACK');
+            }
+            catch { }
+            throw e;
+        }
+    }
     get raw() {
         return this.db;
     }
 }
+// ── PostgreSQL implementation ─────────────────────────────────────────────
+// AsyncLocalStorage stores the current transactional pg client so queries
+// within withTransaction() use the same connection.
+const pgTxClient = new AsyncLocalStorage();
+class LumenDbPg extends LumenDb {
+    constructor(connectionString) {
+        super();
+        this.isPg = true;
+        // Use createRequire for CJS compatibility in ESM context
+        const { Pool } = _require('pg');
+        this.pool = new Pool({ connectionString });
+        this.pool.on('error', (err) => {
+            console.error('[LumenJS PG] Pool error:', err.message);
+        });
+    }
+    /** Convert SQLite-flavoured SQL to PostgreSQL */
+    convertSql(sql) {
+        // INSERT OR IGNORE → INSERT ... ON CONFLICT DO NOTHING
+        const isInsertOrIgnore = /^\s*INSERT\s+OR\s+IGNORE\s+INTO\b/i.test(sql);
+        let result = isInsertOrIgnore
+            ? sql.replace(/INSERT\s+OR\s+IGNORE\s+INTO\b/i, 'INSERT INTO')
+            : sql;
+        // Replace ? with $1, $2, ... positional parameters
+        let i = 0;
+        result = result.replace(/\?/g, () => `$${++i}`);
+        // datetime('now', '+N unit') / datetime('now', '-N unit')
+        result = result.replace(/datetime\s*\(\s*'now'\s*,\s*'([+-]\d+)\s+(\w+)'\s*\)/gi, (_m, offset, unit) => {
+            const op = offset.startsWith('-') ? '-' : '+';
+            const amount = offset.replace(/^[+-]/, '');
+            return `NOW() ${op} INTERVAL '${amount} ${unit}'`;
+        });
+        // datetime('now')
+        result = result.replace(/datetime\s*\(\s*'now'\s*\)/gi, 'NOW()');
+        // json_each(expr) alias → jsonb_array_elements_text(expr::jsonb) AS alias
+        result = result.replace(/\bjson_each\s*\(([^)]+)\)\s+(\w+)/gi, (_m, expr, alias) => `jsonb_array_elements_text(${expr.trim()}::jsonb) AS ${alias}`);
+        // alias.value (from json_each) → alias (jsonb_array_elements_text column is the alias itself)
+        result = result.replace(/\b(\w+)\.value\b/g, '$1');
+        if (isInsertOrIgnore) {
+            result = result.trimEnd() + ' ON CONFLICT DO NOTHING';
+        }
+        return result;
+    }
+    getClient() {
+        // Return transactional client if inside withTransaction, otherwise use pool
+        return pgTxClient.getStore() ?? this.pool;
+    }
+    async all(sql, ...params) {
+        const pgSql = this.convertSql(sql);
+        const res = await this.getClient().query(pgSql, params);
+        return res.rows;
+    }
+    async get(sql, ...params) {
+        const pgSql = this.convertSql(sql);
+        const res = await this.getClient().query(pgSql, params);
+        return res.rows[0];
+    }
+    async run(sql, ...params) {
+        const pgSql = this.convertSql(sql);
+        const res = await this.getClient().query(pgSql, params);
+        const lastInsertRowid = res.rows?.[0]?.id ?? 0;
+        return { changes: res.rowCount ?? 0, lastInsertRowid };
+    }
+    async exec(sql) {
+        // exec is used for DDL / multi-statement — skip placeholder conversion
+        // (DDL has no ? params), just normalize datetime() calls
+        const pgSql = this.convertSql(sql);
+        await this.getClient().query(pgSql);
+    }
+    async withTransaction(fn) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            // All db calls inside fn() will use this client via AsyncLocalStorage
+            const result = await pgTxClient.run(client, fn);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (e) {
+            try {
+                await client.query('ROLLBACK');
+            }
+            catch { }
+            throw e;
+        }
+        finally {
+            client.release();
+        }
+    }
+}
+// ── Singleton management ──────────────────────────────────────────────────
 let _instance = null;
+let _migrationPromise = null;
 export function useDb() {
     if (_instance)
         return _instance;
+    const databaseUrl = process.env.DATABASE_URL;
+    if (databaseUrl && (databaseUrl.startsWith('postgres') || databaseUrl.startsWith('postgresql'))) {
+        _instance = new LumenDbPg(databaseUrl);
+        const projectDir = (() => {
+            try {
+                return getProjectDir();
+            }
+            catch {
+                return process.env.LUMENJS_PROJECT_DIR || process.cwd();
+            }
+        })();
+        _migrationPromise = runPgMigrations(_instance, projectDir);
+        _migrationPromise.catch(err => console.error('[LumenJS] PG migration error:', err.message));
+        return _instance;
+    }
+    // SQLite mode
     const projectDir = getProjectDir();
-    const config = readProjectConfig(projectDir);
-    const dbRelPath = config.db?.path || 'data/db.sqlite';
+    const dbRelPath = (() => {
+        try {
+            const c = fs.readFileSync(path.join(projectDir, 'lumenjs.config.ts'), 'utf-8');
+            const m = c.match(/db\s*:\s*\{[^}]*path\s*:\s*['"]([^'"]+)['"]/);
+            return m ? m[1] : 'data/db.sqlite';
+        }
+        catch {
+            return 'data/db.sqlite';
+        }
+    })();
     const dbPath = path.resolve(projectDir, dbRelPath);
-    // Auto-create directory
     const dbDir = path.dirname(dbPath);
-    if (!fs.existsSync(dbDir)) {
+    if (!fs.existsSync(dbDir))
         fs.mkdirSync(dbDir, { recursive: true });
-    }
-    const db = new Database(dbPath);
-    db.pragma('journal_mode = WAL');
-    db.pragma('foreign_keys = ON');
-    _instance = new LumenDb(db);
-    // Run pending migrations
-    runMigrations(db, projectDir);
+    const rawDb = new Database(dbPath);
+    rawDb.pragma('journal_mode = WAL');
+    rawDb.pragma('foreign_keys = ON');
+    _instance = new LumenDbSqlite(rawDb);
+    autoMigrate(rawDb, projectDir, getRegisteredTables());
+    runSqliteMigrations(rawDb, projectDir);
+    autoSeed(rawDb, projectDir);
     return _instance;
 }
-function runMigrations(db, projectDir) {
+/**
+ * Returns a promise that resolves when the initial DB migrations have completed.
+ * Useful for waiting before serving the first request in PG mode.
+ */
+export function waitForMigrations() {
+    return _migrationPromise ?? Promise.resolve();
+}
+// ── SQLite migration runner ───────────────────────────────────────────────
+function runSqliteMigrations(db, projectDir) {
     const migrationsDir = path.join(projectDir, 'data', 'migrations');
     if (!fs.existsSync(migrationsDir))
         return;
-    // Ensure tracking table exists
     db.exec(`CREATE TABLE IF NOT EXISTS _lumen_migrations (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT NOT NULL UNIQUE,
     applied_at TEXT NOT NULL DEFAULT (datetime('now'))
   )`);
-    const applied = new Set(db.prepare('SELECT name FROM _lumen_migrations').all()
-        .map((row) => row.name));
+    const applied = new Set(db.prepare('SELECT name FROM _lumen_migrations').all().map((r) => r.name));
     const files = fs.readdirSync(migrationsDir)
         .filter(f => f.endsWith('.sql'))
         .sort();
@@ -77,3 +233,26 @@ function runMigrations(db, projectDir) {
         console.log(`[LumenJS] Applied migration: ${file}`);
     }
 }
+// ── PostgreSQL migration runner ───────────────────────────────────────────
+async function runPgMigrations(db, projectDir) {
+    const migrationsDir = path.join(projectDir, 'data', 'migrations', 'postgres');
+    if (!fs.existsSync(migrationsDir))
+        return;
+    await db.exec(`CREATE TABLE IF NOT EXISTS _lumen_migrations (
+    id BIGSERIAL PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    applied_at TIMESTAMP NOT NULL DEFAULT NOW()
+  )`);
+    const applied = new Set((await db.all('SELECT name FROM _lumen_migrations')).map(r => r.name));
+    const files = fs.readdirSync(migrationsDir)
+        .filter(f => f.endsWith('.sql'))
+        .sort();
+    for (const file of files) {
+        if (applied.has(file))
+            continue;
+        const sql = fs.readFileSync(path.join(migrationsDir, file), 'utf-8');
+        await db.exec(sql);
+        await db.run('INSERT INTO _lumen_migrations (name) VALUES (?)', file);
+        console.log(`[LumenJS] Applied PG migration: ${file}`);
+    }
+}

package/dist/db/seed.d.ts

@@ -0,0 +1,12 @@
+import Database from 'better-sqlite3';
+/**
+ * Auto-seed on first DB creation. Called from useDb() after migrations.
+ * Only runs in SQLite mode (PG seeds are handled separately).
+ */
+export declare function autoSeed(db: Database.Database, projectDir: string): void;
+/**
+ * Returns a promise that resolves when any in-progress seed completes.
+ */
+export declare function waitForSeed(): Promise<void>;
+/** Run seed via CLI. If force=true, re-run even if already applied. */
+export declare function runSeed(projectDir: string, force?: boolean): Promise<void>;

package/dist/db/seed.js

@@ -0,0 +1,88 @@
+import path from 'path';
+import fs from 'fs';
+const SEED_TABLE = '_lumen_seed_applied';
+const SEED_NAME = 'data/seed.ts';
+function ensureSeedTableSqlite(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS ${SEED_TABLE} (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL UNIQUE,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )`);
+}
+function isSeedAppliedSqlite(db) {
+    ensureSeedTableSqlite(db);
+    const row = db.prepare(`SELECT 1 FROM ${SEED_TABLE} WHERE name = ?`).get(SEED_NAME);
+    return !!row;
+}
+function markSeedAppliedSqlite(db) {
+    db.prepare(`INSERT OR IGNORE INTO ${SEED_TABLE} (name) VALUES (?)`).run(SEED_NAME);
+}
+async function loadAndRunSeed(projectDir) {
+    const seedPath = path.join(projectDir, 'data', 'seed.ts');
+    const mod = await import(/* @vite-ignore */ seedPath);
+    const seedFn = mod.default || mod;
+    if (typeof seedFn === 'function') {
+        await seedFn();
+    }
+}
+let _seedPromise = null;
+/**
+ * Auto-seed on first DB creation. Called from useDb() after migrations.
+ * Only runs in SQLite mode (PG seeds are handled separately).
+ */
+export function autoSeed(db, projectDir) {
+    if (isSeedAppliedSqlite(db))
+        return;
+    const seedPath = path.join(projectDir, 'data', 'seed.ts');
+    if (!fs.existsSync(seedPath))
+        return;
+    console.log('[LumenJS] Running seed file...');
+    markSeedAppliedSqlite(db);
+    _seedPromise = loadAndRunSeed(projectDir)
+        .then(() => {
+        console.log('[LumenJS] Seed applied.');
+    })
+        .catch(err => {
+        console.error('[LumenJS] Failed to run seed:', err);
+        db.prepare(`DELETE FROM ${SEED_TABLE} WHERE name = ?`).run(SEED_NAME);
+    })
+        .finally(() => {
+        _seedPromise = null;
+    });
+}
+/**
+ * Returns a promise that resolves when any in-progress seed completes.
+ */
+export function waitForSeed() {
+    return _seedPromise ?? Promise.resolve();
+}
+/** Run seed via CLI. If force=true, re-run even if already applied. */
+export async function runSeed(projectDir, force = false) {
+    const seedPath = path.join(projectDir, 'data', 'seed.ts');
+    if (!fs.existsSync(seedPath)) {
+        console.error(`[LumenJS] Seed file not found: ${seedPath}`);
+        process.exit(1);
+    }
+    const { useDb } = await import('./index.js');
+    const lumenDb = useDb();
+    // PG mode: seeds are not tracked via SQLite mechanism
+    if (lumenDb.isPg) {
+        if (!force) {
+            console.log('[LumenJS] PG mode: skipping seed tracking check. Use --force to run anyway.');
+            return;
+        }
+        await loadAndRunSeed(projectDir);
+        console.log('[LumenJS] Seed applied.');
+        return;
+    }
+    const db = lumenDb.raw;
+    ensureSeedTableSqlite(db);
+    if (!force && isSeedAppliedSqlite(db)) {
+        console.log('[LumenJS] Seed already applied. Use --force to re-run.');
+        return;
+    }
+    console.log('[LumenJS] Running seed file...');
+    await loadAndRunSeed(projectDir);
+    markSeedAppliedSqlite(db);
+    console.log('[LumenJS] Seed applied.');
+}

package/dist/db/table.d.ts

@@ -0,0 +1,10 @@
+export interface TableColumn {
+    name: string;
+    type: string;
+}
+export interface TableDefinition {
+    name: string;
+    columns: TableColumn[];
+}
+export declare function defineTable<T extends Record<string, string>>(name: string, columns: T): T;
+export declare function getRegisteredTables(): Map<string, TableDefinition>;

package/dist/db/table.js

@@ -0,0 +1,12 @@
+const _registry = new Map();
+export function defineTable(name, columns) {
+    const parsed = Object.entries(columns).map(([colName, colType]) => ({
+        name: colName,
+        type: colType,
+    }));
+    _registry.set(name, { name, columns: parsed });
+    return columns;
+}
+export function getRegisteredTables() {
+    return _registry;
+}

package/dist/dev-server/config.d.ts

@@ -1,8 +1,11 @@
+import type { SecurityHeadersConfig } from '../shared/security-headers.js';
+import type { RateLimitConfig } from '../shared/rate-limit.js';
 export interface I18nConfig {
     locales: string[];
     defaultLocale: string;
     prefixDefault: boolean;
 }
+export type PrefetchStrategy = 'hover' | 'viewport' | 'none';
 export interface ProjectConfig {
     title: string;
     integrations: string[];
@@ -10,6 +13,14 @@ export interface ProjectConfig {
     db?: {
         path?: string;
     };
+    prefetch: PrefetchStrategy;
+    prerender?: boolean;
+    /** App version for health check. Default: reads from package.json. */
+    version?: string;
+    /** Security headers config. Applied in production. */
+    securityHeaders?: SecurityHeadersConfig;
+    /** Rate limiting config. Applied in production. */
+    rateLimit?: RateLimitConfig;
 }
 /**
  * Reads the project config from lumenjs.config.ts.

package/dist/dev-server/config.js

@@ -9,9 +9,14 @@ const __dirname = path.dirname(__filename);
 export function readProjectConfig(projectDir) {
     let title = 'LumenJS App';
     let integrations = [];
+    let prefetch = 'viewport';
+    let prerender;
+    let i18n;
+    let securityHeaders;
     const configPath = path.join(projectDir, 'lumenjs.config.ts');
     if (fs.existsSync(configPath)) {
         try {
+            // Read the config file once and parse all fields from the same content
             const configContent = fs.readFileSync(configPath, 'utf-8');
             const titleMatch = configContent.match(/title\s*:\s*['"]([^'"]+)['"]/);
             if (titleMatch)
@@ -23,14 +28,33 @@ export function readProjectConfig(projectDir) {
                     .map(s => s.trim().replace(/^['"]|['"]$/g, ''))
                     .filter(Boolean);
             }
-        }
-        catch { /* use defaults */ }
-    }
-    // Parse i18n config (reuse the same file read)
-    let i18n;
-    if (fs.existsSync(configPath)) {
-        try {
-            const configContent = fs.readFileSync(configPath, 'utf-8');
+            const prefetchMatch = configContent.match(/prefetch\s*:\s*['"]([^'"]+)['"]/);
+            if (prefetchMatch) {
+                const val = prefetchMatch[1];
+                if (val === 'hover' || val === 'viewport' || val === 'none') {
+                    prefetch = val;
+                }
+            }
+            const prerenderMatch = configContent.match(/prerender\s*:\s*(true|false)/);
+            if (prerenderMatch) {
+                prerender = prerenderMatch[1] === 'true';
+            }
+            const secHeadersMatch = configContent.match(/securityHeaders\s*:\s*\{([\s\S]*?)\}/);
+            if (secHeadersMatch) {
+                const block = secHeadersMatch[1];
+                const cspMatch = block.match(/contentSecurityPolicy\s*:\s*"([^"]+)"/)
+                    || block.match(/contentSecurityPolicy\s*:\s*'([^']+)'/)
+                    || block.match(/contentSecurityPolicy\s*:\s*`([^`]+)`/);
+                const ppMatch = block.match(/permissionsPolicy\s*:\s*'([^']+)'/)
+                    || block.match(/permissionsPolicy\s*:\s*"([^"]+)"/)
+                    || block.match(/permissionsPolicy\s*:\s*`([^`]+)`/);
+                if (cspMatch || ppMatch) {
+                    securityHeaders = {
+                        ...(cspMatch ? { contentSecurityPolicy: cspMatch[1] } : {}),
+                        ...(ppMatch ? { permissionsPolicy: ppMatch[1] } : {}),
+                    };
+                }
+            }
             const i18nMatch = configContent.match(/i18n\s*:\s*\{([\s\S]*?)\}/);
             if (i18nMatch) {
                 const block = i18nMatch[1];
@@ -50,23 +74,19 @@ export function readProjectConfig(projectDir) {
                 }
             }
         }
-        catch { /* ignore */ }
+        catch { /* use defaults */ }
     }
-    // Parse db config
-    let db;
-    if (fs.existsSync(configPath)) {
+    // Read version from project's package.json
+    let version;
+    const pkgPath = path.join(projectDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
         try {
-            const configContent = fs.readFileSync(configPath, 'utf-8');
-            const dbMatch = configContent.match(/db\s*:\s*\{([\s\S]*?)\}/);
-            if (dbMatch) {
-                const block = dbMatch[1];
-                const pathMatch = block.match(/path\s*:\s*['"]([^'"]+)['"]/);
-                db = pathMatch ? { path: pathMatch[1] } : {};
-            }
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            version = pkg.version;
         }
         catch { /* ignore */ }
     }
-    return { title, integrations, ...(i18n ? { i18n } : {}), ...(db ? { db } : {}) };
+    return { title, integrations, prefetch, version, ...(i18n ? { i18n } : {}), ...(prerender ? { prerender } : {}), ...(securityHeaders ? { securityHeaders } : {}) };
 }
 /**
  * Reads the project title from lumenjs.config.ts (or returns default).

package/dist/dev-server/index-html.d.ts

@@ -15,6 +15,10 @@ export interface IndexHtmlOptions {
         prefixDefault: boolean;
     };
     translations?: Record<string, string>;
+    prefetch?: string;
+    authUser?: any;
+    headContent?: string;
+    base?: string;
 }
 /**
  * Generates the index.html shell that loads the LumenJS app.

package/dist/dev-server/index-html.js

@@ -4,6 +4,9 @@ import { escapeHtml } from '../shared/utils.js';
  * Includes the router, app shell, and optionally the editor bridge.
  */
 export function generateIndexHtml(options) {
+    // Note: script src uses /@lumenjs/ (no base prefix) because Vite's
+    // transformIndexHtml already prepends config.base to absolute URLs.
+    // Including base here would double it when base != '/'.
     const editorScript = options.editorMode
         ? `<script type="module" src="/@lumenjs/editor-bridge"></script>`
         : '';
@@ -29,18 +32,29 @@ export function generateIndexHtml(options) {
         };
         i18nScript = `<script type="application/json" id="__nk_i18n__">${JSON.stringify(i18nData).replace(/</g, '\\u003c')}</script>`;
     }
+    // Auth: inline user data for client hydration
+    let authScript = '';
+    if (options.authUser) {
+        authScript = `<script type="application/json" id="__nk_auth__">${JSON.stringify(options.authUser).replace(/</g, '\\u003c')}</script>`;
+    }
+    // Prefetch strategy inline
+    let prefetchScript = '';
+    if (options.prefetch && options.prefetch !== 'hover') {
+        prefetchScript = `<script type="application/json" id="__nk_prefetch__">${options.prefetch}</script>`;
+    }
     // i18n module is loaded via imports from router-hydration, no separate script needed
-    const hydrateScript = isSSR
-        ? `<script type="module">import '@lit-labs/ssr-client/lit-element-hydrate-support.js';</script>`
-        : '';
+    // Hydrate support is always loaded via the app-shell virtual module (first import)
+    // to avoid Lit module duplication from separate script tags.
     const htmlLang = options.locale || 'en';
     return `<!DOCTYPE html>
 <html lang="${htmlLang}">
 <head>
   <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, interactive-widget=resizes-content" />
   <title>${escapeHtml(options.title)}</title>
-  ${options.integrations?.includes('nuralyui') ? '<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@nuralyui/themes@latest/dist/default.css">' : ''}${options.integrations?.includes('tailwind') ? '\n  <script type="module">import "/styles/tailwind.css";</script>' : ''}
+  <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+  ${options.integrations?.includes('tailwind') ? '<script type="module">import "/styles/tailwind.css";</script>' : ''}
+  ${options.headContent || ''}
   <style>
     *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
     body { font-family: system-ui, -apple-system, sans-serif; min-height: 100vh; }
@@ -48,10 +62,11 @@ export function generateIndexHtml(options) {
   </style>
 </head>
 <body>
+  ${prefetchScript}
   ${i18nScript}
+  ${authScript}
   ${loaderDataScript}
   ${appTag}
-  ${hydrateScript}
   <script type="module" src="/@lumenjs/app-shell"></script>
   ${editorScript}
 </body>

package/dist/dev-server/nuralyui-aliases.d.ts

@@ -1,9 +1,5 @@
 export declare const tagToPackage: Record<string, string>;
 export declare const implicitDeps: Record<string, string[]>;
-/**
- * NuralyUI component alias map — mirrors the studio astro.config.mjs aliases.
- * Points to the component source directories within the studio service.
- */
 export declare function getNuralyUIAliases(nuralyUIPath: string, nuralyCommonPath: string): Record<string, string>;
 /**
  * Resolves the NuralyUI source path dynamically.