odac 1.4.0 → 1.4.1

package/.agent/rules/memory.md

@@ -36,6 +36,9 @@ trigger: always_on
 ## Naming & Text Conventions
 - **ODAC Casing:** Always write "ODAC" in uppercase letters when referring to the framework name in strings, comments, log messages, or user-facing text. **EXCEPTION:** The class name itself (`class Odac`) and variable references to it should remain `Odac` (PascalCase) as per code conventions.
 
+## Documentation Standards
+- **AI Skill Front Matter:** Every file under `docs/ai/skills/**/*.md` must start with YAML front matter containing `name`, `description`, and `metadata.tags`; values must be specific to that document's topic (never copied from generic examples).
+
 ## Testing & Validation
 - **Mandatory Test Coverage:** Every new feature, method, or significant logic change MUST be accompanied by a corresponding unit or integration test.
     - **Verify Correctness:** do not assume code works; prove it with a test that covers both success and failure scenarios (e.g., edge cases, error conditions).

package/.github/workflows/release.yml

@@ -62,6 +62,7 @@ jobs:
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           michelangelo: ${{ secrets.MICHELANGELO }}
+          version: ${{ steps.version.outputs.version }}
         timeout-minutes: 15
         continue-on-error: true
 
@@ -96,7 +97,6 @@ jobs:
         if: steps.ai_notes.outcome == 'success' && steps.version.outputs.version != ''
         with:
           tag_name: v${{ steps.version.outputs.version }}
-          name: ${{ steps.ai_notes.outputs.release-title }}
           body_path: RELEASE_NOTE.md
           draft: false
           prerelease: false

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+### doc
+
+- enhance AI skills documentation with structured YAML front matter and detailed descriptions
+
+### ⚙️ Engine Tuning
+
+- **database:** centralize knex connection bootstrap for runtime and CLI
+
+### 📚 Documentation
+
+- add section for loading and updating AI skills in projects
+
+### 🛠️ Fixes & Improvements
+
+- **auth:** improve token rotation logic and ensure proper cookie attributes
+- **cli:** parse .env values consistently in migration loader
+- **config:** update interpolation regex to support variable names with hyphens
+- **migration:** normalize column-level unique constraints and enhance idempotency in migrations
+- **release:** add version output to release notes and update release title condition
+
+
+
+---
+
+Powered by [⚡ ODAC](https://odac.run)
+
 ### ⚙️ Engine Tuning
 
 - Extract MIME type definitions into a dedicated module.

package/README.md

@@ -53,6 +53,16 @@ cd my-app
 npm run dev
 ```
 
+## 🤖 AI Skills in Projects
+
+Load or update ODAC skills from your project root with:
+
+```bash
+npx odac skills
+```
+
+This command syncs built-in skills to your selected AI tool folder and can be re-run anytime to update them.
+
 ## 📂 Project Structure
 
 ```

package/bin/odac.js

@@ -5,6 +5,8 @@ const path = require('node:path')
 const readline = require('node:readline')
 const {execSync, spawn} = require('node:child_process')
 const cluster = require('node:cluster')
+const Env = require('../src/Env')
+const {buildConnections} = require('../src/Database/ConnectionFactory')
 
 const command = process.argv[2]
 const args = process.argv.slice(3)
@@ -227,6 +229,188 @@ async function manageSkills(targetDir = process.cwd()) {
   }
 }
 
+/**
+ * Bootstraps the database and migration engine, then executes the requested migration command.
+ * Why: Migration commands need DB connections but not the full server stack.
+ * @param {string} cmd - The migration subcommand
+ * @param {string[]} cliArgs - CLI arguments (e.g. --db=analytics)
+ */
+async function runMigration(cmd, cliArgs) {
+  const projectDir = process.cwd()
+  const envPath = path.join(projectDir, '.env')
+  const configPath = path.join(projectDir, 'odac.json')
+
+  // Load .env
+  if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, 'utf8')
+    envContent.split('\n').forEach(line => {
+      line = line.trim()
+      if (!line || line.startsWith('#')) return
+      const idx = line.indexOf('=')
+      if (idx === -1) return
+      const key = line.slice(0, idx).trim()
+      const value = Env._parseValue(line.slice(idx + 1).trim())
+      if (process.env[key] === undefined) process.env[key] = value
+    })
+  }
+
+  // Load config
+  if (!fs.existsSync(configPath)) {
+    console.error('❌ No odac.json found in current directory.')
+    process.exit(1)
+  }
+
+  let config
+  try {
+    let raw = fs.readFileSync(configPath, 'utf8')
+    config = JSON.parse(raw)
+    // Interpolate env vars safely by traversing parsed object values.
+    const interpolateConfig = input => {
+      if (typeof input === 'string') {
+        return input.replace(/\$\{([^{}]+)\}/g, (_, key) => process.env[key] || '')
+      }
+
+      if (Array.isArray(input)) {
+        return input.map(item => interpolateConfig(item))
+      }
+
+      if (input && typeof input === 'object') {
+        const output = {}
+        for (const key of Object.keys(input)) {
+          output[key] = interpolateConfig(input[key])
+        }
+        return output
+      }
+
+      return input
+    }
+
+    config = interpolateConfig(config)
+  } catch (err) {
+    console.error('❌ Failed to parse odac.json:', err.message)
+    process.exit(1)
+  }
+
+  const dbConfig = config.database
+  if (!dbConfig) {
+    console.error('❌ No database configuration found in odac.json.')
+    process.exit(1)
+  }
+
+  const connections = buildConnections(dbConfig)
+
+  for (const key of Object.keys(connections)) {
+    try {
+      await connections[key].raw('SELECT 1')
+    } catch (e) {
+      console.error(`❌ Failed to connect to '${key}' database:`, e.message)
+      process.exit(1)
+    }
+  }
+
+  // Parse --db flag
+  const dbFlag = cliArgs.find(a => a.startsWith('--db='))
+  const options = dbFlag ? {db: dbFlag.split('=')[1]} : {}
+
+  // Initialize migration engine
+  const Migration = require('../src/Database/Migration')
+  Migration.init(projectDir, connections)
+
+  try {
+    if (cmd === 'migrate') {
+      console.log('🔄 Running migrations...\n')
+      const summary = await Migration.migrate(options)
+      printMigrationSummary(summary)
+    } else if (cmd === 'migrate:status') {
+      console.log('📋 Migration Status (dry-run):\n')
+      const summary = await Migration.status(options)
+      printMigrationSummary(summary)
+    } else if (cmd === 'migrate:rollback') {
+      console.log('⏪ Rolling back last batch...\n')
+      const summary = await Migration.rollback(options)
+      printMigrationSummary(summary)
+    } else if (cmd === 'migrate:snapshot') {
+      console.log('📸 Generating schema files from database...\n')
+      const result = await Migration.snapshot(options)
+      for (const [key, files] of Object.entries(result)) {
+        console.log(`  \x1b[36m${key}\x1b[0m: ${files.length} schema file(s) generated`)
+        for (const f of files) {
+          console.log(`    → ${path.relative(projectDir, f)}`)
+        }
+      }
+      console.log('\n✅ Snapshot complete.')
+    }
+  } catch (err) {
+    console.error('❌ Migration error:', err.message)
+    process.exit(1)
+  } finally {
+    for (const conn of Object.values(connections)) {
+      await conn.destroy()
+    }
+  }
+}
+
+/**
+ * Formats and prints migration operation summary to stdout.
+ * @param {object} summary - Migration result per connection
+ */
+function printMigrationSummary(summary) {
+  let totalOps = 0
+
+  for (const [key, result] of Object.entries(summary)) {
+    console.log(`  \x1b[36m[${key}]\x1b[0m`)
+
+    const allOps = [...(result.schema || []), ...(result.files || []), ...(result.seeds || [])]
+
+    if (allOps.length === 0) {
+      console.log('    Nothing to do.')
+    }
+
+    for (const op of allOps) {
+      totalOps++
+      const label = formatOp(op)
+      console.log(`    ${label}`)
+    }
+    console.log('')
+  }
+
+  console.log(totalOps > 0 ? `✅ ${totalOps} operation(s) completed.` : '✅ Everything is up to date.')
+}
+
+/**
+ * Formats a single migration operation for CLI display.
+ * @param {object} op - Operation descriptor
+ * @returns {string} Formatted label
+ */
+function formatOp(op) {
+  switch (op.type) {
+    case 'create_table':
+      return `\x1b[32m+ CREATE TABLE\x1b[0m ${op.table}`
+    case 'add_column':
+      return `\x1b[32m+ ADD COLUMN\x1b[0m ${op.table}.${op.column}`
+    case 'drop_column':
+      return `\x1b[31m- DROP COLUMN\x1b[0m ${op.table}.${op.column}`
+    case 'alter_column':
+      return `\x1b[33m~ ALTER COLUMN\x1b[0m ${op.table}.${op.column}`
+    case 'add_index':
+      return `\x1b[32m+ ADD INDEX\x1b[0m ${op.table} (${op.index.columns.join(', ')})`
+    case 'drop_index':
+      return `\x1b[31m- DROP INDEX\x1b[0m ${op.table} (${op.index.columns.join(', ')})`
+    case 'pending_file':
+      return `\x1b[33m⏳ PENDING\x1b[0m ${op.name}`
+    case 'applied_file':
+      return `\x1b[32m✓ APPLIED\x1b[0m ${op.name}`
+    case 'rolled_back':
+      return `\x1b[33m↩ ROLLED BACK\x1b[0m ${op.name}`
+    case 'seed_insert':
+      return `\x1b[32m+ SEED INSERT\x1b[0m ${op.table} (${op.key})`
+    case 'seed_update':
+      return `\x1b[33m~ SEED UPDATE\x1b[0m ${op.table} (${op.key})`
+    default:
+      return `  ${op.type}`
+  }
+}
+
 async function run() {
   if (command === 'init') {
     const projectName = args[0] || '.'
@@ -376,6 +560,8 @@ async function run() {
     require('../index.js')
   } else if (command === 'skills') {
     await manageSkills()
+  } else if (command === 'migrate' || command === 'migrate:status' || command === 'migrate:rollback' || command === 'migrate:snapshot') {
+    await runMigration(command, args)
   } else {
     console.log('Usage:')
     console.log('  npx odac init            (Interactive mode)')
@@ -384,6 +570,10 @@ async function run() {
     console.log('  npx odac build           (Production build)')
     console.log('  npx odac start           (Start server)')
     console.log('  npx odac skills          (Sync AI Agent skills)')
+    console.log('  npx odac migrate         (Run pending migrations)')
+    console.log('  npx odac migrate:status  (Show pending changes)')
+    console.log('  npx odac migrate:rollback (Rollback last batch)')
+    console.log('  npx odac migrate:snapshot (Reverse-engineer DB to schema/)')
   }
 
   rl.close()

package/docs/ai/skills/SKILL.md

@@ -1,8 +1,8 @@
 ---
-name: odac-framework
-description: Comprehensive AI developer skills for the ODAC Framework (Backend & Frontend).
+name: odac-framework-skill-catalog
+description: Comprehensive ODAC backend and frontend AI skill index for architecture, security, and high-performance application development.
 metadata:
-  tags: nodejs, framework, backend, frontend, architecture, security
+  tags: odac, skills, backend, frontend, architecture, security, performance
 ---
 
 ## When to use
@@ -22,6 +22,7 @@ Read the specific rule files based on whether you are working on the Backend or
 - [backend/forms.md](backend/forms.md) - Form processing and Validation logic
 - [backend/ipc.md](backend/ipc.md) - Inter-Process Communication and state sharing
 - [backend/mail.md](backend/mail.md) - Transactional email sending
+- [backend/migrations.md](backend/migrations.md) - Schema-first, auto-run, cluster-safe DB migrations
 - [backend/request_response.md](backend/request_response.md) - Handling Odac.Request and Odac.Response
 - [backend/routing.md](backend/routing.md) - Route definitions, Middlewares, and Error Pages
 - [backend/storage.md](backend/storage.md) - Persistent key-value storage (LMDB)

package/docs/ai/skills/backend/authentication.md

@@ -1,3 +1,10 @@
+---
+name: backend-authentication-realtime-skill
+description: Secure ODAC authentication patterns for sessions, guards, passwordless flows, and realtime channel protection.
+metadata:
+  tags: backend, authentication, session, auth-guard, magic-link, realtime, security
+---
+
 # Backend Authentication & Realtime Skill
 
 Secure user authentication, session management, and bidirectional communication.

package/docs/ai/skills/backend/config.md

@@ -1,3 +1,10 @@
+---
+name: backend-configuration-skill
+description: ODAC configuration standards for odac.json usage, environment variable mapping, and secure runtime settings.
+metadata:
+  tags: backend, configuration, odac-json, environment, secrets, settings
+---
+
 # Backend Configuration Skill
 
 Managing application settings using `odac.json` and environment variables.

package/docs/ai/skills/backend/controllers.md

@@ -1,3 +1,10 @@
+---
+name: backend-controllers-skill
+description: Best practices for ODAC controller architecture, class-based routing, and clean request handling boundaries.
+metadata:
+  tags: backend, controllers, class-based, route-mapping, architecture, maintainability
+---
+
 # Backend Controllers Skill
 
 Controllers are the bridge between routes and views/services. This skill covers how to write clean, professional controllers in ODAC.

package/docs/ai/skills/backend/cron.md

@@ -1,3 +1,10 @@
+---
+name: backend-cron-jobs-skill
+description: Reliable ODAC cron scheduling patterns for background automation, timing control, and safe execution design.
+metadata:
+  tags: backend, cron, scheduler, background-jobs, automation, timing
+---
+
 # Backend Cron Jobs Skill
 
 ODAC provides a built-in cron system for automating background tasks without external dependencies.
@@ -21,14 +28,14 @@ Odac.Route.cron('cleanup').at('03:00'); // Runs daily at 03:00
 // controller/cron/cleanup.js
 module.exports = async (Odac) => {
   console.log('Running nightly cleanup...');
-  await Odac.Db.table('logs').where('created_at', '<', 'NOW() - INTERVAL 30 DAY').delete();
+  await Odac.DB.table('logs').where('created_at', '<', 'NOW() - INTERVAL 30 DAY').delete();
 };
 ```
 
 ### 2. Inline Function Cron
 ```javascript
 Odac.Route.cron(async () => {
-  const stats = await Odac.Db.table('orders').count();
+  const stats = await Odac.DB.table('orders').count();
   console.log('Current orders:', stats);
 }).everyHour(1);
 ```

package/docs/ai/skills/backend/database.md

@@ -1,3 +1,10 @@
+---
+name: backend-database-skill
+description: High-performance ODAC database querying patterns using the built-in query builder with secure and efficient data access.
+metadata:
+  tags: backend, database, query-builder, sql, indexing, performance, security
+---
+
 # Backend Database Skill
 
 High-performance database operations using the ODAC Query Builder.
@@ -9,13 +16,22 @@ High-performance database operations using the ODAC Query Builder.
 
 ## Patterns
 ```javascript
-const user = await Odac.Db.table('users')
+const user = await Odac.DB.table('users')
   .select('id', 'name', 'email')
   .where('status', 'active')
   .first();
 
-await Odac.Db.table('posts').insert({
+await Odac.DB.table('posts').insert({
   title: 'Hello',
   user_id: 1
 });
 ```
+
+## Migration Awareness
+1.  **Schema-First**: Structural DB changes must be defined in `schema/*.js`.
+2.  **Auto-Migrate**: Migrations run automatically at startup from `Database.init()`.
+3.  **Cluster-Safe**: Migration execution is limited to primary process (`cluster.isPrimary`).
+4.  **Indexes**: Keep index definitions in schema so add/drop is managed automatically.
+5.  **Data Changes**: Use `migration/*.js` only for one-time data transformation.
+
+See: [migrations.md](./migrations.md)

package/docs/ai/skills/backend/forms.md

@@ -1,10 +1,17 @@
+---
+name: backend-forms-validation-skill
+description: Secure ODAC form processing workflow with validation, CSRF protection, and safe request-to-database handling.
+metadata:
+  tags: backend, forms, validation, csrf, input-security, request-processing
+---
+
 # Backend Forms & Validation Skill
 
 Processing form data securely and validating inputs.
 
 ## Rules
 1.  **Validator**: Always use `Odac.Validator` for input.
-2.  **Auto-save**: Use `Odac.Db.table().save(Odac.Request.post())` for quick inserts.
+2.  **Auto-save**: Use `Odac.DB.table().save(Odac.Request.post())` for quick inserts.
 3.  **CSRF**: Ensure `{{ TOKEN }}` is in your HTML forms.
 
 ## Patterns

package/docs/ai/skills/backend/ipc.md

@@ -1,3 +1,10 @@
+---
+name: backend-ipc-skill
+description: ODAC inter-process communication guidance for memory and Redis drivers, shared state, and distributed coordination.
+metadata:
+  tags: backend, ipc, redis, cluster, distributed-state, synchronization
+---
+
 # Backend IPC (Inter-Process Communication) Skill
 
 ODAC provides a built-in IPC system to share data and sync states across application workers or multiple servers.

package/docs/ai/skills/backend/mail.md

@@ -1,3 +1,10 @@
+---
+name: backend-mail-skill
+description: Transactional email integration patterns in ODAC using fluent mail APIs, templating, and transport configuration.
+metadata:
+  tags: backend, mail, smtp, transactional-email, templating, notifications
+---
+
 # Backend Mail Skill
 
 Sending transactional emails using the fluent `Odac.Mail` service.

package/docs/ai/skills/backend/migrations.md

@@ -0,0 +1,80 @@
+---
+name: backend-migrations-skill
+description: Schema-first ODAC migration strategy for deterministic database evolution, index sync, and cluster-safe execution.
+metadata:
+  tags: backend, migrations, schema, database-evolution, indexes, cluster-safety
+---
+
+# Backend Migrations Skill
+
+Schema-first, zero-config migration strategy for ODAC.
+
+## Architectural Approach
+ODAC migrations are **declarative**. The `schema/` directory is the single source of truth for final DB state. The migration engine diffs desired schema vs current DB and applies create/alter/drop operations automatically.
+
+## Core Rules
+1. **Source of Truth**: Always update `schema/*.js` files, not historical migration chains, for structural changes.
+2. **Auto Execution**: Migrations run automatically during app startup via `Database.init()`.
+3. **Cluster Safety**: Auto-migration runs only on `cluster.isPrimary` to prevent race conditions.
+4. **Index Sync**: Define indexes in schema; engine adds/removes them automatically.
+5. **Drop Behavior**: If a column/index is removed from schema, it is removed from DB on next startup.
+6. **Seeds**: Use `seed` + `seedKey` for idempotent reference data.
+7. **Data Transformations**: Use imperative files under `migration/` only for one-time data migration logic.
+
+## Reference Patterns
+### 1. Schema File (Final State)
+```javascript
+// schema/users.js
+'use strict'
+
+module.exports = {
+  columns: {
+    id: {type: 'increments'},
+    email: {type: 'string', length: 255, nullable: false},
+    role: {type: 'enum', values: ['admin', 'user'], default: 'user'},
+    timestamps: {type: 'timestamps'}
+  },
+  indexes: [
+    {columns: ['email'], unique: true}
+  ],
+  seed: [
+    {email: 'admin@example.com', role: 'admin'}
+  ],
+  seedKey: 'email'
+}
+```
+
+### 2. Multi-Database Layout
+```
+schema/
+  users.js            # default DB
+  analytics/
+    events.js         # analytics DB
+```
+
+### 3. Imperative Data Migration (One-Time)
+```javascript
+// migration/20260225_001_backfill_roles.js
+module.exports = {
+  async up(db) {
+    await db('users').whereNull('role').update({role: 'user'})
+  },
+  async down(db) {
+    await db('users').where('role', 'user').update({role: null})
+  }
+}
+```
+
+### 4. CLI Operations
+```bash
+npx odac migrate
+npx odac migrate:status
+npx odac migrate:rollback
+npx odac migrate:snapshot
+```
+
+## Performance and Safety Notes
+- Keep schema declarations deterministic and minimal.
+- Prefer additive changes; drops are destructive and should be intentional.
+- Ensure high-cardinality lookup columns are indexed in schema definitions.
+- For very large tables, plan expensive column rewrites as dedicated data migrations.

package/docs/ai/skills/backend/request_response.md

@@ -1,3 +1,10 @@
+---
+name: backend-request-response-skill
+description: ODAC request parsing and response composition patterns for consistent, secure, and predictable API behavior.
+metadata:
+  tags: backend, request, response, headers, status-codes, json, api
+---
+
 # Backend Request & Response Skill
 
 Handling incoming data and sending structured responses.

package/docs/ai/skills/backend/routing.md

@@ -1,3 +1,10 @@
+---
+name: backend-routing-middleware-skill
+description: High-performance ODAC routing and middleware orchestration for secure request pipelines and scalable URL mapping.
+metadata:
+  tags: backend, routing, middleware, pipeline, auth, performance, url-matching
+---
+
 # Backend Routing & Middleware Skill
 
 Routing manages the request pipeline, directing URLs to controllers while applying security and business logic via middlewares.

package/docs/ai/skills/backend/storage.md

@@ -1,3 +1,10 @@
+---
+name: backend-persistent-storage-skill
+description: Embedded ODAC storage usage patterns with LMDB for sub-millisecond key-value persistence across workers.
+metadata:
+  tags: backend, storage, lmdb, key-value, persistence, high-performance
+---
+
 # Backend Persistent Storage Skill
 
 ODAC provides a high-performance, embedded key-value store using LMDB, exposed via `Odac.Storage`.

package/docs/ai/skills/backend/streaming.md

@@ -1,3 +1,10 @@
+---
+name: backend-streaming-sse-skill
+description: Server-Sent Events streaming patterns in ODAC for realtime one-way updates with safe connection lifecycle management.
+metadata:
+  tags: backend, streaming, sse, realtime, event-stream, connection-lifecycle
+---
+
 # Backend Streaming API Skill
 
 Real-time data streaming using Server-Sent Events (SSE).

package/docs/ai/skills/backend/structure.md

@@ -1,3 +1,10 @@
+---
+name: backend-structure-services-skill
+description: ODAC project organization rules for directory structure, service classes, and request-scoped architecture.
+metadata:
+  tags: backend, structure, services, architecture, request-scope, organization
+---
+
 # Backend Structure & Services Skill
 
 ODAC follows a strictly organized directory structure and focuses on request-scoped architecture. This skill explains how to organize code and use Service Classes.
@@ -31,7 +38,7 @@ class User {
 
   async getProfile(id) {
     // Access database or auth via this.Odac
-    return await this.Odac.Db.table('users').where('id', id).first();
+    return await this.Odac.DB.table('users').where('id', id).first();
   }
 }
 module.exports = User;

package/docs/ai/skills/backend/translations.md

@@ -1,3 +1,10 @@
+---
+name: backend-translations-i18n-skill
+description: Internationalization patterns in ODAC for locale files, placeholders, and multilingual rendering workflows.
+metadata:
+  tags: backend, i18n, translations, locale, placeholders, multilingual
+---
+
 # Backend Translations (i18n) Skill
 
 ODAC provides built-in support for internationalization, allowing for easy multi-language application development.

package/docs/ai/skills/backend/utilities.md

@@ -1,3 +1,10 @@
+---
+name: backend-utilities-skill
+description: Practical ODAC utility patterns for string processing, hashing, encryption, and request flow control.
+metadata:
+    tags: backend, utilities, strings, hashing, encryption, flow-control
+---
+
 # Backend Utilities Skill
 
 String manipulation, hashing, and flow control.

package/docs/ai/skills/backend/validation.md

@@ -1,3 +1,10 @@
+---
+name: backend-validation-skill
+description: Fluent ODAC validation strategies for input hardening, brute-force protection, and standardized error responses.
+metadata:
+  tags: backend, validation, fluent-api, input-security, brute-force, error-handling
+---
+
 # Backend Validation Skill
 
 The `Validator` service provides a fluent, chainable API for securing user input and enforcing business rules.

package/docs/ai/skills/backend/views.md

@@ -1,3 +1,10 @@
+---
+name: backend-views-templates-skill
+description: ODAC server-side rendering guidelines for template performance, skeleton layouts, and safe output rendering.
+metadata:
+  tags: backend, views, templates, ssr, xss-protection, skeleton, rendering
+---
+
 # Backend Views & Templates Skill
 
 High-performance server-side rendering using ODAC's optimized template engine.

package/docs/ai/skills/frontend/core.md

@@ -1,3 +1,10 @@
+---
+name: frontend-core-skill
+description: Core ODAC frontend architecture patterns based on actions, lifecycle hooks, and event-driven UI behavior.
+metadata:
+  tags: frontend, odac-js, actions, lifecycle, events, ui-architecture
+---
+
 # Frontend Core Skill
 
 The foundational principles of the `odac.js` library for building reactive and interactive user interfaces.