@stacksjs/defaults 0.75.484 → 0.75.487

package/app/Actions/Dashboard/Search/GlobalSearchAction.ts

@@ -1,18 +1,19 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions/runtime'
-import { env } from '@stacksjs/env'
-import { readdirSync } from 'node:fs'
-import { basename, extname, join } from 'node:path'
-import process from 'node:process'
-import { frameworkDefaultsRoot } from '@stacksjs/path'
+import { getDatabaseDialect, sqlHelpers } from '@stacksjs/database/runtime'
+import { overridesReady } from '@stacksjs/config'
+import { resolveModelSources } from '@stacksjs/database/model-sources'
+import { hiddenModelColumns } from '../../../../resources/functions/dashboard/model-columns'
 import { resolveDashboardModel } from '../../../../resources/functions/dashboard/model-access'
-import { dashboardOperationalError } from '../dashboard-response'
+import { dashboardOperationalError, dashboardOperationalIssue } from '../dashboard-response'
 
 interface SearchableModel {
   name: string
   table: string
   slug: string
   fields: string[]
+  primaryKey: string
+  model: any
   icon: string
 }
 
@@ -68,36 +69,6 @@ function isSafeIdentifier(value: string): boolean {
   return /^[A-Z_][A-Z0-9_]*$/i.test(value) && value.length <= 64
 }
 
-function modelFiles(root: string): string[] {
-  const files: string[] = []
-
-  function walk(directory: string): void {
-    let entries
-    try {
-      entries = readdirSync(directory, { withFileTypes: true })
-    }
-    catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT')
-        return
-      throw new Error(`Could not scan searchable models in ${directory}: ${error instanceof Error ? error.message : String(error)}`)
-    }
-
-    for (const entry of entries) {
-      const file = join(directory, entry.name)
-      if (entry.isDirectory()) {
-        walk(file)
-        continue
-      }
-      if (!['.ts', '.js'].includes(extname(entry.name))) continue
-      if (entry.name.startsWith('.') || entry.name.startsWith('_') || entry.name.startsWith('index')) continue
-      files.push(file)
-    }
-  }
-
-  walk(root)
-  return files.sort()
-}
-
 function iconForModel(name: string): string {
   const icons: Record<string, string> = {
     User: 'i-hugeicons-user-group',
@@ -115,17 +86,11 @@ function iconForModel(name: string): string {
 }
 
 async function loadSearchableModels(): Promise<SearchableModel[]> {
-  const defaultsRoot = join(frameworkDefaultsRoot(), 'app/Models')
-  const userRoot = join(process.cwd(), 'app/Models')
-  const merged = new Map<string, string>()
-
-  for (const file of modelFiles(defaultsRoot))
-    merged.set(basename(file, extname(file)), file)
-  for (const file of modelFiles(userRoot))
-    merged.set(basename(file, extname(file)), file)
+  await overridesReady
+  const sources = resolveModelSources()?.models ?? []
 
   const models: SearchableModel[] = []
-  for (const [fallbackName, file] of merged) {
+  for (const { name: fallbackName, file } of sources) {
     try {
       const module = await import(file)
       const definition = await resolveDashboardModel(fallbackName, module.default ?? module)
@@ -134,9 +99,11 @@ async function loadSearchableModels(): Promise<SearchableModel[]> {
       const search = definition.traits?.useSearch
       if (!search || typeof search !== 'object' || !Array.isArray(search.searchable)) continue
 
+      const hidden = hiddenModelColumns(definition)
+      const stored = new Set(Object.keys(definition.attributes ?? {}).map(snakeCase))
       const fields: string[] = (search.searchable as unknown[])
         .map((field: unknown) => snakeCase(String(field)))
-        .filter((field: string) => isSafeIdentifier(field) && !HIDDEN_FIELDS.has(field))
+        .filter((field: string) => isSafeIdentifier(field) && !HIDDEN_FIELDS.has(field) && !hidden.has(field) && stored.has(field))
       const table = String(definition.table || pluralize(snakeCase(name)))
       if (fields.length === 0 || !isSafeIdentifier(table)) continue
 
@@ -145,6 +112,8 @@ async function loadSearchableModels(): Promise<SearchableModel[]> {
         table,
         slug: kebabCase(name),
         fields: [...new Set(fields)],
+        primaryKey: String(definition.primaryKey || 'id'),
+        model: definition,
         icon: iconForModel(name),
       })
     }
@@ -190,6 +159,28 @@ function resultSubtitle(model: SearchableModel, row: Record<string, unknown>, ti
   return undefined
 }
 
+/** Use the configured ORM connection, including PostgreSQL, and select only approved fields. */
+export async function searchModelRows(Model: any, fields: string[], primaryKey: string, term: string, limit = RESULTS_PER_MODEL): Promise<Array<Record<string, unknown>>> {
+  if (!isSafeIdentifier(primaryKey) || fields.some(field => !isSafeIdentifier(field)))
+    throw new TypeError('Search columns must be model identifiers.')
+  if (fields.length === 0) return []
+  const dialect = sqlHelpers(getDatabaseDialect())
+  const quote = (column: string) => dialect.isMysql ? `\`${column}\`` : `"${column}"`
+  const rows = await Model.query()
+    .select(...new Set([primaryKey, ...fields]))
+    .whereGroup((group: any) => {
+      for (const [index, column] of fields.entries()) {
+        const match = `LOWER(CAST(${quote(column)} AS ${dialect.isMysql ? 'CHAR' : 'TEXT'})) LIKE LOWER(?)`
+        group = index === 0 ? group.whereRaw(match, `%${term}%`) : group.orWhereRaw(match, `%${term}%`)
+      }
+      return group
+    })
+    .orderBy(primaryKey, 'asc')
+    .limit(limit)
+    .get()
+  return rows.map((row: any) => typeof row.toJSON === 'function' ? row.toJSON() : row.attributes ?? row)
+}
+
 export default new Action({
   name: 'GlobalSearchAction',
   description: 'Searches fields declared by model useSearch traits and groups matching records by model.',
@@ -202,52 +193,18 @@ export default new Action({
     try {
       const models = await catalog()
       if (models.length === 0) return { results: {}, unavailable: [] }
-      const { Database } = await import('bun:sqlite')
-      const db = new Database(env.DB_DATABASE_PATH || 'database/stacks.sqlite', { readonly: true })
       const results: Record<string, SearchResult[]> = {}
       const unavailable: SearchUnavailable[] = []
 
-      try {
-        for (const model of models) {
-          if (Object.keys(results).length >= MAX_GROUPS) break
-
-          const columns = db.query(`PRAGMA table_info(${model.table})`).all() as Array<{ name: string }>
-          if (columns.length === 0) {
-            unavailable.push({
-              model: model.name,
-              reason: `Table ${model.table} has not been migrated.`,
-            })
-            continue
-          }
-
-          const available = new Set(columns.map(column => column.name))
-          const fields = model.fields.filter(field => available.has(field))
-          if (fields.length === 0) {
-            unavailable.push({
-              model: model.name,
-              reason: 'Declared useSearch fields are not present in the migrated table.',
-            })
-            continue
-          }
-
-          const selected = [...new Set(['id', ...fields])].filter(field => available.has(field))
-          const where = fields.map(field => `${field} LIKE ? COLLATE NOCASE`).join(' OR ')
-          const bindings = fields.map(() => `%${q}%`)
-          let rows: Array<Record<string, unknown>>
-          try {
-            rows = db
-              .query(`SELECT ${selected.join(', ')} FROM ${model.table} WHERE ${where} LIMIT ?`)
-              .all(...bindings, RESULTS_PER_MODEL) as Array<Record<string, unknown>>
-          }
-          catch (error) {
-            throw new Error(`Could not search model ${model.name}: ${error instanceof Error ? error.message : String(error)}`)
-          }
+      for (const model of models) {
+        if (Object.keys(results).length >= MAX_GROUPS) break
+        try {
+          const rows = await searchModelRows(model.model, model.fields, model.primaryKey, q, RESULTS_PER_MODEL)
           if (rows.length === 0) continue
-
-          results[model.name] = rows.map((row, index) => {
+          results[model.name] = rows.map((row) => {
             const title = resultTitle(model, row)
             return {
-              id: (row.id as string | number | undefined) ?? index,
+              id: row[model.primaryKey] as string | number,
               title,
               subtitle: resultSubtitle(model, row, title),
               href: `/models/${model.slug}?q=${encodeURIComponent(q)}`,
@@ -255,9 +212,10 @@ export default new Action({
             }
           })
         }
-      }
-      finally {
-        db.close()
+        catch (error) {
+          unavailable.push({ model: model.name, reason: 'Could not search model. Check its migrated schema and declared useSearch fields.' })
+          dashboardOperationalIssue(error, 'Could not search model.', `GlobalSearchAction.${model.name}`)
+        }
       }
 
       return { results, unavailable }

package/app/Actions/Dashboard/Search/SearchEngineIndexAction.ts

@@ -0,0 +1,59 @@
+import { Action } from '@stacksjs/actions/runtime'
+import { overridesReady, searchEngine } from '@stacksjs/config'
+import { resolveModelSources } from '@stacksjs/database/model-sources'
+import { searchIndexName, settingsFromSearchTrait, useSearchEngine } from '@stacksjs/search-engine'
+import { resolveDashboardModel } from '../../../../resources/functions/dashboard/model-access'
+import { dashboardOperationalError, dashboardOperationalIssue } from '../dashboard-response'
+
+export default new Action({
+  name: 'Search Engine Inventory',
+  description: 'Inspect the configured search engine and indexes declared by application models.',
+  method: 'GET',
+  async handle() {
+    try {
+      await overridesReady
+      const models = []
+      for (const source of resolveModelSources()?.models ?? []) {
+        const module = await import(source.file)
+        const Model = await resolveDashboardModel(source.name, module.default ?? module)
+        const trait = Model?.traits?.useSearch
+        if (!trait) continue
+        const settings = settingsFromSearchTrait(typeof trait === 'object' ? trait : {})
+        models.push({
+          name: source.name,
+          index: searchIndexName(trait, Model.table),
+          searchable: settings.searchableAttributes ?? ['*'],
+          filterable: settings.filterableAttributes ?? [],
+          sortable: settings.sortableAttributes ?? [],
+          displayed: settings.displayedAttributes ?? ['*'],
+        })
+      }
+      let connected = false
+      let unavailable: string | null = null
+      let indexes: Array<{ name: string, documents: number | null }> = []
+      let timeout: ReturnType<typeof setTimeout> | undefined
+      try {
+        const result = await Promise.race([
+          Promise.resolve(useSearchEngine().listAllIndexes()),
+          new Promise<never>((_, reject) => { timeout = setTimeout(() => reject(new Error('Search engine inspection timed out.')), 8000) }),
+        ])
+        if (!Array.isArray(result?.results)) throw new TypeError('Search index response must contain results.')
+        indexes = result.results.map(index => {
+          const value = index as unknown as Record<string, unknown>
+          return { name: String(value.uid), documents: typeof value.num_documents === 'number' ? value.num_documents : null }
+        })
+        connected = true
+      }
+      catch (error) {
+        dashboardOperationalIssue(error, 'Search engine could not be reached.', 'SearchEngineIndexAction.provider')
+        unavailable = 'Search engine could not be reached. Check config/search-engine.ts, provider credentials, and the running service.'
+      }
+      finally { if (timeout) clearTimeout(timeout) }
+      models.sort((a, b) => a.name.localeCompare(b.name))
+      return { driver: searchEngine.driver, connected, unavailable, indexes, models }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Search engine inventory could not be loaded.', 'SearchEngineIndexAction')
+    }
+  },
+})

package/app/Models/QueueWorker.ts

@@ -0,0 +1,17 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation/runtime'
+
+/** Bounded worker telemetry, shared by queue workers and the dashboard process. */
+export default defineModel({
+  name: 'QueueWorker',
+  table: 'queue_workers',
+  primaryKey: 'worker_id',
+  autoIncrement: false,
+  dashboard: { access: false },
+  indexes: [{ name: 'queue_workers_heartbeat_at_index', columns: ['heartbeat_at'] }],
+  attributes: {
+    worker_id: { required: true, fillable: true, validation: { rule: schema.string().required().max(255) } },
+    snapshot: { type: 'text', required: true, fillable: true, validation: { rule: schema.string().required() } },
+    heartbeat_at: { type: 'bigint', required: true, fillable: true, validation: { rule: schema.integer().required() } },
+  },
+} as const)

package/functions/jobs.ts

@@ -145,3 +145,17 @@ export function useJobs() {
     retryFailedJobs: retryAllFailedJobs,
   }
 }
+
+export interface JobDefinition {
+  name: string
+  description: string
+  queue: string
+  tries: number
+  timeout: number | null
+  schedule: string
+  enabled: boolean
+}
+
+export async function fetchJobDefinitions(): Promise<{ data: JobDefinition[] }> {
+  return dashboardApi<{ data: JobDefinition[] }>('/api/dashboard/jobs/definitions')
+}

package/functions/search-engine.ts

@@ -0,0 +1,13 @@
+import { dashboardApi } from './dashboard-api'
+
+export interface SearchEngineInventory {
+  driver: string
+  connected: boolean
+  unavailable: string | null
+  indexes: Array<{ name: string, documents: number | null }>
+  models: Array<{ name: string, index: string, searchable: string[], filterable: string[], sortable: string[], displayed: string[] }>
+}
+
+export async function fetchSearchEngineInventory(): Promise<SearchEngineInventory> {
+  return dashboardApi<SearchEngineInventory>('/api/dashboard/search-engine')
+}

package/ide/vscode/package.json

@@ -2,7 +2,7 @@
   "publisher": "Stacks",
   "name": "vscode-stacks",
   "displayName": "Stacks",
-  "version": "0.75.484",
+  "version": "0.75.487",
   "description": "Stacks, built into VS Code: stx templates, pickier linting and formatting, encrypted env files, the dev server preview and every buddy command. No other extensions required.",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/defaults",
   "type": "module",
   "sideEffects": false,
-  "version": "0.75.484",
+  "version": "0.75.487",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
@@ -45,7 +45,7 @@
   "dependencies": {
     "@iconify-json/f7": "^1.2.2",
     "@iconify-json/hugeicons": "^1.2.35",
-    "@stacksjs/mobile": "0.75.484",
+    "@stacksjs/mobile": "0.75.487",
     "@stacksjs/sanitizer": "0.2.807",
     "@stacksjs/stx": "0.2.807",
     "@xterm/addon-fit": "^0.11.0",

package/resources/components/Dashboard/Jobs/JobDashboard.stx

@@ -1,8 +1,19 @@
+@import('../UI/Table')
+
 <script client>
-import type { DashboardJob, JobStatsResponse } from '../../../../functions/jobs'
-import { fetchJobs, fetchJobStats, retryJob } from '../../../../functions/jobs'
+import type { DashboardJob, JobDefinition, JobStatsResponse } from '../../../../functions/jobs'
+import { fetchJobDefinitions, fetchJobs, fetchJobStats, retryJob } from '../../../../functions/jobs'
 import { pushToast } from '../../../../functions/toasts'
 
+const definitions = state<JobDefinition[]>([])
+const definitionColumns = [
+  { key: 'name', label: 'Job', subtitleKey: 'description', sortable: true },
+  { key: 'queue', label: 'Queue', sortable: true },
+  { key: 'tries', label: 'Attempts', type: 'number' },
+  { key: 'timeout', label: 'Timeout (seconds)', type: 'number', emptyText: 'Default' },
+  { key: 'schedule', label: 'Schedule', emptyText: 'On dispatch' },
+  { key: 'enabled', label: 'Enabled', type: 'boolean' },
+]
 const jobs = state<DashboardJob[]>([])
 const stats = state<JobStatsResponse | null>(null)
 const isLoading = state(true)
@@ -16,10 +27,12 @@ async function loadDashboard(): Promise<void> {
   isLoading.set(true)
   loadError.set('')
   try {
-    const [list, summary] = await Promise.all([
+    const [list, summary, catalog] = await Promise.all([
       fetchJobs({ page: 1, perPage: 10 }),
       fetchJobStats(),
+      fetchJobDefinitions(),
     ])
+    definitions.set(catalog.data)
     jobs.set(list.data)
     stats.set(summary)
   }
@@ -55,7 +68,7 @@ onMount(() => {
   <header class="flex items-start justify-between">
     <div>
       <h1 class="font-bold text-2xl text-gray-900 dark:text-white">Jobs</h1>
-      <p class="mt-1 text-gray-500 text-sm dark:text-neutral-400">Queue activity from Job and FailedJob records plus the current worker metrics.</p>
+      <p class="mt-1 text-gray-500 text-sm dark:text-neutral-400">Application job definitions, queued work, failures and shared worker metrics.</p>
     </div>
     <Button variant="secondary" :loading="isLoading()" @click="loadDashboard">
       <span :if="!isLoading()" class="h-4 w-4 i-hugeicons-refresh"></span>
@@ -84,11 +97,17 @@ onMount(() => {
     </div>
   </section>
 
+  <section>
+    <h2 class="mb-3 font-semibold text-gray-900 dark:text-white">Job definitions</h2>
+    <p :if="!isLoading && !loadError && definitions().length === 0" class="py-8 text-gray-500 text-sm">No application jobs have been defined.</p>
+    <Table :if="definitions().length > 0" :columns="definitionColumns" :data="definitions" row-key="name" paginated :page-size="25" />
+  </section>
+
   <section>
     <div class="flex items-end justify-between mb-3">
       <div>
         <h2 class="font-semibold text-gray-900 dark:text-white">Recent jobs</h2>
-        <p class="mt-1 text-gray-500 text-sm dark:text-neutral-400">No synthetic throughput is shown. Metrics reflect the running queue process.</p>
+        <p class="mt-1 text-gray-500 text-sm dark:text-neutral-400">Metrics use worker heartbeats. Stopped sessions are retained for seven days.</p>
       </div>
       <StxLink to="/jobs/history" class="inline-flex items-center font-medium text-blue-600 text-sm dark:text-blue-400">
         Full history

package/resources/components/Dashboard/Queue/QueueDashboard.stx

@@ -37,7 +37,6 @@ const QUEUE_COLUMNS = [
   { key: 'name', label: 'Queue', sortable: true, subtitleKey: 'status', class: 'font-medium text-gray-900 dark:text-white' },
   count('pending', 'Pending'),
   count('active', 'Active'),
-  count('completed', 'Completed'),
   count('failed', 'Failed'),
   { ...count('total', 'Total'), class: 'font-medium text-gray-900 dark:text-white' },
 ]
@@ -97,7 +96,7 @@ onMount(() => {
 </script>
 
 <div class="space-y-6">
-  <PageHeader title="Queue" description="Recorded queue state and current-process worker metrics.">
+  <PageHeader title="Queue" description="Recorded queue state and shared worker heartbeats.">
   <div class="flex gap-2 items-center">
     <span :class="'inline-flex items-center px-2.5 py-1 font-medium text-xs rounded-full ' + (queueConnected() ? 'text-green-700 bg-green-100 dark:text-green-300 dark:bg-green-950' : 'text-red-700 bg-red-100 dark:text-red-300 dark:bg-red-950')">
       <span :class="'mr-1.5 h-1.5 w-1.5 rounded-full ' + (queueConnected() ? 'bg-green-500' : 'bg-red-500')"></span>
@@ -137,7 +136,7 @@ onMount(() => {
         <h2 class="font-semibold text-gray-900 dark:text-white">Queue breakdown</h2>
         <p class="mt-1 text-gray-500 text-sm dark:text-neutral-400">Status totals come from Job records grouped by queue name.</p>
       </div>
-      <p class="text-gray-500 text-sm dark:text-neutral-400">{{ stats()?.throughputPerMinute || 0 }} jobs/min in this process</p>
+      <p class="text-gray-500 text-sm dark:text-neutral-400">{{ stats()?.throughputPerMinute || 0 }} jobs/min across reporting workers</p>
     </div>
     <div :if="!isLoading() && queueRows().length === 0" class="px-5 py-12 text-center">
       <div class="mb-3 mx-auto h-9 w-9 text-gray-400 i-hugeicons-queue-02"></div>

package/resources/components/Dashboard/Search/SearchEngineDashboard.stx

@@ -0,0 +1,58 @@
+@import('../UI/Table')
+
+<script client>
+import type { SearchEngineInventory } from '../../../../functions/search-engine'
+import { fetchSearchEngineInventory } from '../../../../functions/search-engine'
+
+const inventory = state<SearchEngineInventory | null>(null)
+const loading = state(true)
+const error = state('')
+const modelRows = derived(() => (inventory()?.models ?? []).map(model => ({
+  ...model,
+  searchable: model.searchable.join(', '),
+  filterable: model.filterable.join(', ') || 'None',
+  sortable: model.sortable.join(', ') || 'None',
+})))
+const columns = [
+  { key: 'name', label: 'Model', sortable: true },
+  { key: 'index', label: 'Index', sortable: true },
+  { key: 'searchable', label: 'Searchable fields' },
+  { key: 'filterable', label: 'Filterable fields' },
+  { key: 'sortable', label: 'Sortable fields' },
+]
+const indexColumns = [
+  { key: 'name', label: 'Index', sortable: true },
+  { key: 'documents', label: 'Documents', type: 'number', emptyText: 'Not reported' },
+]
+async function refresh() {
+  loading.set(true)
+  error.set('')
+  try { inventory.set(await fetchSearchEngineInventory()) }
+  catch { error.set('Search inventory could not be loaded. Try refreshing.') }
+  finally { loading.set(false) }
+}
+onMount(() => { void refresh() })
+</script>
+
+<div class="space-y-6">
+  <PageHeader title="Search Engine" description="Configured search service and model indexing conventions.">
+    <Button variant="secondary" :loading="loading" @click="refresh">Refresh</Button>
+  </PageHeader>
+  <p :if="loading" role="status" class="text-gray-500 text-sm">Loading search inventory...</p>
+  <p :if="error" role="alert" class="p-4 text-red-700 text-sm dark:text-red-300 bg-red-50 dark:bg-red-950/30 rounded-lg">{{ error }}</p>
+  <section :if="inventory" class="p-5 bg-white dark:bg-neutral-800 border border-gray-200 rounded-lg dark:border-neutral-700">
+    <p class="font-semibold text-gray-900 dark:text-white">{{ inventory()?.driver }}: {{ inventory()?.connected ? 'Connected' : 'Unavailable' }}</p>
+    <p :if="inventory()?.unavailable" role="status" class="mt-2 text-amber-700 text-sm dark:text-amber-300">{{ inventory()?.unavailable }}</p>
+    <p class="mt-2 text-gray-500 text-sm dark:text-neutral-400">Models are discovered from the application schema and their useSearch traits.</p>
+  </section>
+  <section>
+    <h2 class="mb-3 font-semibold text-gray-900 dark:text-white">Searchable models</h2>
+    <p :if="!loading && modelRows().length === 0" class="py-8 text-gray-500 text-sm">No models declare the useSearch trait.</p>
+    <Table :if="modelRows().length > 0" :columns="columns" :data="modelRows" row-key="name" paginated :page-size="25" />
+  </section>
+  <section :if="inventory()?.connected">
+    <h2 class="mb-3 font-semibold text-gray-900 dark:text-white">Provider indexes</h2>
+    <p :if="inventory()?.indexes.length === 0" class="py-8 text-gray-500 text-sm">The configured service has no indexes yet.</p>
+    <Table :if="inventory()?.indexes.length" :columns="indexColumns" :data="inventory()?.indexes || []" row-key="name" paginated :page-size="25" />
+  </section>
+</div>

package/resources/functions/dashboard/model-columns.ts

@@ -0,0 +1,12 @@
+/** Shared projection boundary for model records and global search. */
+const HIDDEN_COLUMNS = new Set(['password', 'remember_token', 'api_token', 'access_token', 'refresh_token', 'secret', 'two_factor_secret'])
+
+export function hiddenModelColumns(Model: any): Set<string> {
+  const hidden = new Set(HIDDEN_COLUMNS)
+  for (const [name, definition] of Object.entries(Model?.attributes ?? {})) {
+    if ((definition as { hidden?: boolean })?.hidden)
+      hidden.add(name.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase())
+  }
+  return hidden
+}
+

package/resources/functions/dashboard/sidebar.ts

@@ -18,6 +18,7 @@ type ModelCategory = 'userland' | 'data' | 'commerce' | 'content' | 'marketing'
  * full type imports aren't available. Keep in sync with the source.
  */
 interface DashboardModelOptionsLite {
+  access?: boolean
   enabled?: boolean
   label?: string
   icon?: string
@@ -278,7 +279,7 @@ export function loadDiscoveredModels(): DiscoveredModel[] {
  * explicitly disabled so callers can skip the row.
  */
 function effectiveCategory(m: DiscoveredModel): string | undefined {
-  if (m.dashboard?.enabled === false)
+  if (m.dashboard?.access === false || m.dashboard?.enabled === false)
     return undefined
   if (m.dashboard?.section)
     return m.dashboard.section
@@ -372,6 +373,7 @@ export function buildNavSections(
     { to: '/actions', icon: 'bolt', text: 'Actions' },
     { to: '/commands', icon: 'terminal', text: 'Commands' },
     { to: '/queue', icon: 'queue', text: 'Queue' },
+    { to: '/search-engine', icon: 'search', text: 'Search Engine' },
     { to: '/jobs', icon: 'briefcase', text: 'Jobs' },
     { to: '/jobs/history', icon: 'clock', text: 'Job History' },
     { to: '/queries', icon: 'search', text: 'Queries' },
@@ -470,7 +472,7 @@ export function buildNavSections(
       { to: '/marketing/lists', icon: 'list-settings', text: 'Lists' },
       { to: '/marketing/social-posts', icon: 'clock', text: 'Social Posts' },
       { to: '/marketing/campaigns', icon: 'rocket', text: 'Campaigns' },
-      { to: '/marketing/abandoned-carts', icon: 'cart', text: 'Abandoned Carts' },
+      ...(toggles.commerce ? [{ to: '/marketing/abandoned-carts', icon: 'cart', text: 'Abandoned Carts' }] : []),
       // Product reviews are commerce records, so with commerce off this page
       // could only say so (stacksjs/stacks#3186).
       ...(toggles.commerce ? [{ to: '/marketing/reviews', icon: 'star', text: 'Reviews' }] : []),