odac 1.4.9 → 1.4.11

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+### ✨ What's New
+
+- add esbuild-powered JS/TS frontend pipeline
+- **cache:** add proxy cache support with Odac.cache() method
+
+### 🛠️ Fixes & Improvements
+
+- **frontend:** enforce pipeline .js output, handle watcher rejections and skip esbuild directory scans
+
+
+
+---
+
+Powered by [⚡ ODAC](https://odac.run)
+
+### 🛠️ Fixes & Improvements
+
+- **cache:** preserve Knex chain for insert operations during invalidation
+- **database:** resolve duplicate error handler bug in insert cache invalidation
+- **migration:** add column type comparison to detect schema changes
+- **migration:** handle PostgreSQL primary key type changes safely
+- **migration:** preserve column nullable state when altering without explicit schema
+- **write-buffer:** auto-generate nanoid values for buffered inserts
+
+
+
+---
+
+Powered by [⚡ ODAC](https://odac.run)
+
 ### ⚙️ Engine Tuning
 
 - migrate hashing from BCrypt to scrypt and update Odac.Var documentation and validation logic

package/bin/odac.js

@@ -141,6 +141,195 @@ function getTailwindConfigs() {
   return configs
 }
 
+/**
+ * Resolves JS/TS entry points from 'view/js' and returns esbuild-compatible configs.
+ * Supports multiple entry points: each .js/.ts/.mjs/.mts file in view/js/ becomes a separate bundle.
+ * Why: Mirrors the Tailwind CSS pipeline pattern for zero-config frontend asset compilation.
+ * @returns {Array<{ input: string, output: string, name: string }>}
+ */
+function getJsConfigs() {
+  const jsDir = path.join(process.cwd(), 'view/js')
+  const outputDir = path.join(process.cwd(), 'public/assets/js')
+  const configs = []
+
+  if (!fs.existsSync(jsDir) || !fs.lstatSync(jsDir).isDirectory()) return configs
+
+  const validExtensions = ['.ts', '.js', '.mts', '.mjs']
+  const files = fs.readdirSync(jsDir).filter(file => {
+    const fullPath = path.join(jsDir, file)
+    if (!fs.lstatSync(fullPath).isFile()) return false
+    const ext = path.extname(file).toLowerCase()
+    return validExtensions.includes(ext) && !file.startsWith('_')
+  })
+
+  fs.mkdirSync(outputDir, {recursive: true})
+
+  for (const file of files) {
+    const input = path.join(jsDir, file)
+    const baseName = path.basename(file, path.extname(file))
+    const output = path.join(outputDir, `${baseName}.js`)
+
+    configs.push({input, output, name: file})
+  }
+
+  return configs
+}
+
+/**
+ * Reads the project's odac.json and returns the js pipeline configuration.
+ * Merges user config with sensible defaults for zero-config operation.
+ * @returns {{ target: string, minify: boolean, sourcemap: boolean, bundle: boolean, obfuscate: boolean|string }}
+ */
+function getJsPipelineOptions() {
+  const configPath = path.join(process.cwd(), 'odac.json')
+  const defaults = {
+    target: 'es2020',
+    minify: true,
+    sourcemap: false,
+    bundle: true,
+    obfuscate: false
+  }
+
+  try {
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
+      if (config.js && typeof config.js === 'object') {
+        return {...defaults, ...config.js}
+      }
+    }
+  } catch {
+    // Config read failure is non-fatal; use defaults
+  }
+
+  return defaults
+}
+
+/**
+ * Resolves esbuild mangle/obfuscation options based on the obfuscate config level.
+ * Why: Provides lightweight code obfuscation without external dependencies by leveraging
+ * esbuild's built-in property mangling and identifier minification capabilities.
+ *
+ * Levels:
+ * - false (default): No obfuscation, only standard minification.
+ * - true / "low": Mangles properties starting with _ (private-by-convention).
+ * - "medium": Mangles _ properties + top-level names + applies aggressive mangling.
+ * - "high": Maximum obfuscation — mangles all properties matching common patterns,
+ *           drops console/debugger, and rewrites identifiers aggressively.
+ *
+ * @param {boolean|string} level Obfuscation level
+ * @returns {object} esbuild-compatible options to spread into the build config
+ */
+function getObfuscationOptions(level) {
+  if (!level) return {}
+
+  const normalized = level === true ? 'low' : String(level).toLowerCase()
+
+  if (normalized === 'low') {
+    return {
+      mangleProps: /^_/
+    }
+  }
+
+  if (normalized === 'medium') {
+    return {
+      mangleProps: /^_/,
+      drop: ['debugger'],
+      pure: ['console.debug', 'console.trace']
+    }
+  }
+
+  if (normalized === 'high') {
+    return {
+      mangleProps: /^[_$]/,
+      drop: ['debugger', 'console'],
+      legalComments: 'none',
+      keepNames: false
+    }
+  }
+
+  return {}
+}
+
+/**
+ * Builds JS/TS entry points using esbuild.
+ * Why: Provides TypeScript transpilation, bundling, minification, and tree-shaking in a single pass.
+ * @param {Array<{ input: string, output: string, name: string }>} configs Entry point configurations
+ * @param {{ target: string, minify: boolean, sourcemap: boolean, bundle: boolean }} options Build options
+ * @param {boolean} [production=false] Whether to enable production optimizations
+ * @returns {Promise<boolean>} True if all builds succeeded
+ */
+async function buildJs(configs, options, production = false) {
+  if (configs.length === 0) return true
+
+  const esbuild = require('esbuild')
+  const obfuscation = production ? getObfuscationOptions(options.obfuscate) : {}
+  let hasError = false
+
+  const buildPromises = configs.map(async ({input, output, name}) => {
+    try {
+      await esbuild.build({
+        entryPoints: [input],
+        outfile: output,
+        bundle: options.bundle,
+        minify: production ? true : options.minify,
+        sourcemap: options.sourcemap,
+        target: options.target,
+        platform: 'browser',
+        format: 'iife',
+        treeShaking: true,
+        legalComments: 'none',
+        logLevel: 'warning',
+        ...obfuscation
+      })
+    } catch (err) {
+      console.error(`❌ \x1b[31m[ODAC Script Error]\x1b[0m Build failed for ${name}:`, err.message)
+      hasError = true
+    }
+  })
+
+  await Promise.all(buildPromises)
+  return !hasError
+}
+
+/**
+ * Starts esbuild watch contexts for JS/TS entry points.
+ * Why: Provides instant rebuilds during development, matching the Tailwind CSS watcher pattern.
+ * @param {Array<{ input: string, output: string, name: string }>} configs Entry point configurations
+ * @param {{ target: string, minify: boolean, sourcemap: boolean, bundle: boolean }} options Build options
+ * @returns {Promise<Array<{ dispose: Function }>>} Array of esbuild watch contexts for cleanup
+ */
+async function watchJs(configs, options) {
+  if (configs.length === 0) return []
+
+  const esbuild = require('esbuild')
+  const contexts = []
+
+  for (const {input, output, name} of configs) {
+    try {
+      const ctx = await esbuild.context({
+        entryPoints: [input],
+        outfile: output,
+        bundle: options.bundle,
+        minify: false,
+        sourcemap: true,
+        target: options.target,
+        platform: 'browser',
+        format: 'iife',
+        treeShaking: false,
+        legalComments: 'none',
+        logLevel: 'warning'
+      })
+
+      await ctx.watch()
+      contexts.push(ctx)
+    } catch (err) {
+      console.error(`❌ \x1b[31m[ODAC Script Error]\x1b[0m Watch failed for ${name}:`, err.message)
+    }
+  }
+
+  return contexts
+}
+
 /**
  * Manages the AI Agent skills synchronization.
  * @param {string} targetDir The directory to sync skills into.
@@ -529,6 +718,31 @@ async function run() {
       process.on('SIGINT', cleanup)
       process.on('SIGTERM', cleanup)
       process.on('exit', cleanup)
+
+      // JS/TS Pipeline — esbuild watch mode
+      const jsConfigs = getJsConfigs()
+      if (jsConfigs.length > 0) {
+        const jsOptions = getJsPipelineOptions()
+        const jsNames = jsConfigs.map(c => c.name).join(', ')
+        console.log(`📦 \x1b[36mODAC Scripts:\x1b[0m Watching for changes (${jsNames})`)
+
+        watchJs(jsConfigs, jsOptions)
+          .then(contexts => {
+            const jsCleanup = () => {
+              contexts.forEach(ctx => {
+                try {
+                  ctx.dispose()
+                } catch {}
+              })
+            }
+            process.on('SIGINT', jsCleanup)
+            process.on('SIGTERM', jsCleanup)
+            process.on('exit', jsCleanup)
+          })
+          .catch(err => {
+            console.error(`❌ \x1b[31m[ODAC Script Error]\x1b[0m Failed to initialize JS watcher:`, err.message)
+          })
+      }
     }
 
     require('../index.js')
@@ -554,7 +768,22 @@ async function run() {
     if (hasError) {
       process.exit(1)
     } else {
-      console.log('✅ All builds completed successfully!')
+      console.log('✅ All CSS builds completed successfully!')
+    }
+
+    // JS/TS Pipeline — production build with minification and tree-shaking
+    const jsConfigs = getJsConfigs()
+    if (jsConfigs.length > 0) {
+      const jsOptions = getJsPipelineOptions()
+      const jsNames = jsConfigs.map(c => c.name).join(', ')
+      console.log(`📦 Compiling scripts (${jsNames})...`)
+
+      const jsSuccess = await buildJs(jsConfigs, jsOptions, true)
+      if (!jsSuccess) {
+        process.exit(1)
+      } else {
+        console.log('✅ All script builds completed successfully!')
+      }
     }
   } else if (command === 'start') {
     process.env.NODE_ENV = 'production'

package/docs/ai/skills/SKILL.md

@@ -20,16 +20,17 @@ Read the specific rule files based on whether you are working on the Backend or
 - [backend/cron.md](backend/cron.md) - Scheduled background tasks and automation
 - [backend/database.md](backend/database.md) - Query Builder, Write-Behind Cache, and DB best practices
 - [backend/forms.md](backend/forms.md) - Form processing and Validation logic
+- [backend/image-processing.md](backend/image-processing.md) - High-performance server-side image manipulation
 - [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/odac-var.md](backend/odac-var.md) - Odac.Var (Fluent String Manipulation, Hashing, Encryption)
 - [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)
 - [backend/streaming.md](backend/streaming.md) - Server-Sent Events (SSE) and Streaming API
 - [backend/structure.md](backend/structure.md) - Project organization and Service Classes
 - [backend/translations.md](backend/translations.md) - Multi-language support (i18n)
-- [backend/odac-var.md](backend/odac-var.md) - Odac.Var (Fluent String Manipulation, Hashing, Encryption)
 - [backend/utilities.md](backend/utilities.md) - Flow Control (abort, direct, session)
 - [backend/validation.md](backend/validation.md) - Input sanitization and security checks
 - [backend/views.md](backend/views.md) - Template syntax, skeletons, and server-side JS
@@ -39,3 +40,4 @@ Read the specific rule files based on whether you are working on the Backend or
 - [frontend/forms.md](frontend/forms.md) - AJAX form handling and API requests
 - [frontend/navigation.md](frontend/navigation.md) - AJAX Navigation (SPA) behavior
 - [frontend/realtime.md](frontend/realtime.md) - WebSocket Hubs and EventSource usage
+- [frontend/scripts.md](frontend/scripts.md) - esbuild-powered JS/TS frontend pipeline

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

@@ -2,7 +2,7 @@
 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
+  tags: backend, request, response, headers, status-codes, json, api, cache, proxy
 ---
 
 # Backend Request & Response Skill
@@ -40,3 +40,23 @@ module.exports = function(Odac) {
   return "Raw text response";
 };
 ```
+
+### 3. Proxy Cache Control
+Enable ODAC Proxy caching for static or semi-static page responses. Sets `X-ODAC-Cache` and `Cache-Control` headers automatically.
+
+**ODAC Ecosystem Only** — requires the ODAC Proxy. Has no effect in standalone deployments.
+
+```javascript
+module.exports = function(Odac) {
+  Odac.cache(3600) // Cache for 1 hour
+  Odac.View.skeleton('main').set('content', 'about')
+}
+```
+
+**Rules:**
+- `Odac.cache(seconds)` — positive integer only. Throws `TypeError` otherwise.
+- Overrides any previously set `Cache-Control` header for the request.
+- **ODAC Proxy is smart:** automatically invalidates cache when content changes or dynamic content is detected.
+- **Despite smart invalidation, never use on:** user-specific pages (dashboards, profiles, account pages), pages with session data, auth state, or per-user content. Do not rely on auto-detection as a safety net.
+
+**Good candidates:** marketing pages, blog posts, docs, product listings (no personalization), static pages (about, FAQ, contact).

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

@@ -0,0 +1,36 @@
+---
+name: frontend-scripts-typescript-skill
+description: ODAC frontend JS/TS pipeline guidelines for writing, bundling, and optimizing client-side scripts using esbuild.
+metadata:
+  tags: frontend, javascript, typescript, esbuild, bundling, minification, tree-shaking, scripts, assets
+---
+
+# Frontend Scripts & TypeScript Skill
+
+Zero-config frontend asset pipeline powered by esbuild for TypeScript transpilation, bundling, minification, and tree-shaking.
+
+## Core Rules
+1.  **Entry Points**: Place `.ts`, `.js`, `.mts`, or `.mjs` files in `view/js/`. Each becomes a separate bundle.
+2.  **Partials Convention**: Files starting with `_` (e.g., `_utils.ts`) are ignored as entry points — use them as shared imports only.
+3.  **Output Path**: Compiled files go to `public/assets/js/{name}.js`.
+4.  **No TypeScript Enforcement**: Both TypeScript and plain JavaScript are supported equally.
+5.  **Import Resolution**: Use standard ES module `import`/`export` between files. esbuild bundles everything into a single output per entry point.
+6.  **Configuration**: Optional `js` key in `odac.json` for `target`, `minify`, `sourcemap`, and `bundle` settings.
+
+## Development vs Production
+- **`odac dev`**: Watch mode with source maps, no minification, instant rebuilds.
+- **`odac build`**: Full minification, tree-shaking, and dead code elimination.
+
+## Example Structure
+```
+view/js/
+├── app.ts          → public/assets/js/app.js
+├── admin.ts        → public/assets/js/admin.js
+├── _api.ts         (shared module, not compiled)
+└── _utils.ts       (shared module, not compiled)
+```
+
+## HTML Integration
+```html
+<script src="/assets/js/app.js"></script>
+```

package/docs/backend/03-config/00-configuration-overview.md

@@ -161,6 +161,19 @@ const nodeEnv = process.env.NODE_ENV
 }
 ```
 
+**Scripts (JS/TS Pipeline):**
+```json
+{
+  "js": {
+    "target": "es2020",
+    "minify": true,
+    "sourcemap": false,
+    "bundle": true,
+    "obfuscate": false
+  }
+}
+```
+
 **Debug Mode:**
 Enable verbose logging for development. This helps in troubleshooting by inspecting detailed logs for system actions like sending emails (e.g., SMTP connection details, server responses). Default is `false`.
 

package/docs/backend/06-request-and-response/03-proxy-cache.md

@@ -0,0 +1,77 @@
+## 🚀 Proxy Cache
+
+`Odac.cache()` lets you tell the ODAC Proxy to cache the current page's HTML response, so repeat visitors get a near-instant response without hitting your application server at all.
+
+> **ODAC Ecosystem Only:** This feature works exclusively within the ODAC ecosystem. It relies on the `X-ODAC-Cache` header that only the ODAC Proxy understands and acts upon.
+
+### Basic Usage
+
+Call `Odac.cache(seconds)` at the top of your controller with a TTL (time-to-live) in seconds:
+
+```javascript
+module.exports = function (Odac) {
+  Odac.cache(3600) // Cache this page for 1 hour
+
+  Odac.set('title', 'About Us')
+  Odac.View.skeleton('main').set('content', 'about')
+}
+```
+
+That's it. The ODAC Proxy handles the rest.
+
+### How It Works
+
+When `Odac.cache(seconds)` is called, ODAC sets two response headers:
+
+| Header | Value | Purpose |
+|--------|-------|---------|
+| `X-ODAC-Cache` | `3600` | Tells the ODAC Proxy to cache this response for the given TTL |
+| `Cache-Control` | `public, max-age=3600` | Standard browser/CDN cache directive |
+
+The ODAC Proxy intercepts the response, stores it, and serves it directly on subsequent requests — bypassing your application entirely until the TTL expires.
+
+### Smart Cache Invalidation
+
+The ODAC Proxy is intelligent about cache invalidation. You don't need to manually clear the cache in most cases:
+
+- **Content changes:** If the underlying page content changes (e.g. a file is updated or a deployment happens), the Proxy detects this and automatically invalidates the cache on the next request.
+- **Dynamic content detection:** If the Proxy detects that a response contains dynamic or user-specific content, it cancels the cache for that response automatically.
+
+### When to Use It
+
+`Odac.cache()` is designed for pages where the HTML output is **identical for all visitors**:
+
+✅ **Good candidates:**
+- Marketing and landing pages
+- Blog posts and articles
+- Documentation pages
+- Product listing pages (without personalization)
+- Static "About", "Contact", "FAQ" pages
+
+❌ **Do not use on:**
+- Pages with user-specific content (dashboards, profiles, account pages)
+- Pages that display session data or authentication state
+- Pages with per-user pricing, recommendations, or notifications
+- Any page where the HTML output differs between users
+
+> Even though the ODAC Proxy can detect dynamic content and cancel caching, you should not rely on this as a safety net. If a page is user-specific, simply don't call `Odac.cache()`.
+
+### TTL Reference
+
+| Scenario | Recommended TTL |
+|----------|----------------|
+| Frequently updated content (news, blog) | `300` – `900` (5–15 min) |
+| Semi-static content (docs, product pages) | `3600` – `86400` (1–24 hrs) |
+| Fully static pages (about, landing) | `86400` – `604800` (1–7 days) |
+
+### Error Handling
+
+`Odac.cache()` throws a `TypeError` if the argument is not a positive integer:
+
+```javascript
+Odac.cache(3600)    // ✅ Valid
+Odac.cache(0)       // ❌ TypeError
+Odac.cache(-1)      // ❌ TypeError
+Odac.cache('3600')  // ❌ TypeError
+Odac.cache(3.5)     // ❌ TypeError
+```

package/docs/backend/07-views/12-scripts-and-typescript.md

@@ -0,0 +1,156 @@
+# 📦 Scripts & TypeScript
+
+ODAC comes with built-in, **Zero-Config** support for frontend JavaScript and TypeScript. Write your scripts in `view/js/`, and ODAC handles transpilation, bundling, minification, and tree-shaking automatically — just like the Tailwind CSS pipeline.
+
+## How it Works
+
+The framework uses [esbuild](https://esbuild.github.io/) under the hood for blazing-fast builds:
+
+1.  **Development (`npm run dev`)**:
+    *   ODAC watches all `.ts`, `.js`, `.mts`, and `.mjs` files in `view/js/`.
+    *   Changes trigger instant rebuilds (sub-millisecond).
+    *   Source maps are enabled for easy debugging.
+
+2.  **Production (`npm run build`)**:
+    *   All entry points are bundled, minified, and tree-shaken.
+    *   Output goes to `public/assets/js/{name}.js`.
+
+3.  **Serving (`npm start`)**:
+    *   The compiled JS files are served statically. No runtime overhead.
+
+## Quick Start
+
+Create a file at **`view/js/app.ts`** (or `app.js` for plain JavaScript):
+
+```typescript
+// view/js/app.ts
+interface User {
+  id: number
+  name: string
+}
+
+const greet = (user: User): string => {
+  return `Hello, ${user.name}!`
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+  console.log(greet({ id: 1, name: 'World' }))
+})
+```
+
+That's it. Run `npm run dev` and ODAC compiles it to `public/assets/js/app.js`.
+
+## Entry Points & Imports
+
+Each file in `view/js/` becomes a separate entry point (bundle). You can use standard ES module imports between files:
+
+```
+view/js/
+├── app.ts          → public/assets/js/app.js
+├── admin.ts        → public/assets/js/admin.js
+├── _utils.ts       (ignored — partial/import only)
+└── _api.ts         (ignored — partial/import only)
+```
+
+> **Convention:** Files starting with `_` (underscore) are **not** compiled as entry points. Use them as shared modules that get imported by your entry points.
+
+```typescript
+// view/js/_api.ts (shared module — not compiled on its own)
+export const fetchUsers = async (): Promise<unknown> => {
+  const res = await fetch('/api/users')
+  return res.json()
+}
+```
+
+```typescript
+// view/js/admin.ts (entry point — compiled to admin.js)
+import { fetchUsers } from './_api'
+
+document.addEventListener('DOMContentLoaded', async () => {
+  const users = await fetchUsers()
+  console.log(users)
+})
+```
+
+esbuild bundles the imported code into the final output — no extra network requests.
+
+## TypeScript or JavaScript — Your Choice
+
+ODAC doesn't force TypeScript on you. Both work equally well:
+
+| Extension | Behavior |
+|-----------|----------|
+| `.ts`     | TypeScript with full type-checking support |
+| `.js`     | Plain JavaScript, passed through as-is |
+| `.mts`    | TypeScript with ES module syntax |
+| `.mjs`    | JavaScript with ES module syntax |
+
+## HTML Integration
+
+In your skeleton or layout files, reference the compiled output:
+
+```html
+<script src="/assets/js/app.js"></script>
+```
+
+The default project template already includes this in `skeleton/main.html`.
+
+## Configuration (Optional)
+
+ODAC works with zero configuration, but you can customize the JS pipeline in `odac.json`:
+
+```json
+{
+  "js": {
+    "target": "es2020",
+    "minify": true,
+    "sourcemap": false,
+    "bundle": true,
+    "obfuscate": false
+  }
+}
+```
+
+| Option      | Default    | Description |
+|-------------|------------|-------------|
+| `target`    | `"es2020"` | JavaScript target version (`es2015`, `es2020`, `esnext`, etc.) |
+| `minify`    | `true`     | Enable minification in production builds |
+| `sourcemap` | `false`    | Generate source maps in production (always enabled in dev) |
+| `bundle`    | `true`     | Bundle imported modules into a single file |
+| `obfuscate` | `false`    | Code obfuscation level (`false`, `true`/`"low"`, `"medium"`, `"high"`) |
+
+## Obfuscation
+
+ODAC supports three levels of code obfuscation for production builds. Obfuscation is disabled by default and only applied during `odac build` — development mode is never obfuscated.
+
+### Levels
+
+| Level    | What it does |
+|----------|-------------|
+| `false`  | No obfuscation. Standard minification only. |
+| `true` / `"low"` | Mangles properties starting with `_` (private-by-convention). |
+| `"medium"` | Low + drops `debugger` statements + removes `console.debug` and `console.trace`. |
+| `"high"` | Maximum — mangles `_` and `$` prefixed properties, drops all `console.*` calls and `debugger` statements. |
+
+### Example
+
+```json
+{
+  "js": {
+    "obfuscate": "medium"
+  }
+}
+```
+
+> **Tip:** Start with `"low"` or `"medium"`. The `"high"` level mangles `$`-prefixed properties which may break code that interacts with external libraries using `$` conventions (e.g., jQuery, some frameworks). Test thoroughly before deploying with `"high"`.
+
+## What You Get
+
+- **TypeScript Support** — Write type-safe frontend code without any setup
+- **Bundling** — `import`/`export` between files, everything merged into one output
+- **Minification** — Whitespace removal, variable shortening, dead code elimination
+- **Tree-Shaking** — Unused exports are automatically removed
+- **Obfuscation** — Optional property mangling and console stripping (3 levels)
+- **Source Maps** — Enabled in development for easy debugging
+- **Multiple Entry Points** — Separate bundles for different pages/sections
+- **Sub-millisecond Rebuilds** — esbuild's native speed keeps your dev loop instant

package/docs/index.json

@@ -165,6 +165,10 @@
         {
           "file": "02-sending-a-response-replying-to-the-user.md",
           "title": "Response Object"
+        },
+        {
+          "file": "03-proxy-cache.md",
+          "title": "Proxy Cache"
         }
       ]
     },
@@ -215,6 +219,10 @@
         {
           "file": "10-styling-and-tailwind.md",
           "title": "Styling & Tailwind CSS"
+        },
+        {
+          "file": "12-scripts-and-typescript.md",
+          "title": "Scripts & TypeScript"
         }
       ]
     },

package/eslint.config.mjs

@@ -38,7 +38,7 @@ export default defineConfig([
   },
   {
     files: ['template/**/*.js'],
-    ignores: ['template/public/**/*.js'],
+    ignores: ['template/public/**/*.js', 'template/view/js/**/*.js'],
     languageOptions: {
       globals: {
         ...globals.node,
@@ -56,6 +56,25 @@ export default defineConfig([
       'prettier/prettier': 'error'
     }
   },
+  {
+    files: ['template/view/js/**/*.js'],
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        Odac: 'readonly'
+      },
+      sourceType: 'script'
+    },
+    plugins: {
+      js,
+      prettier: prettierPlugin
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...prettierConfig.rules,
+      'prettier/prettier': 'error'
+    }
+  },
   {
     files: ['template/public/**/*.js'],
     languageOptions: {