@newsails/veil-studio 1.0.0

package/server/utils/db.js

@@ -0,0 +1,484 @@
+'use strict'
+
+const path = require('path')
+const fs = require('fs')
+const Database = require('better-sqlite3')
+const { DB_PATH, PROJECT_DIR } = require('./config.js')
+
+let db = null
+
+function initDB() {
+  const studioDir = path.join(PROJECT_DIR, '.veil-studio')
+  fs.mkdirSync(studioDir, { recursive: true })
+
+  db = new Database(DB_PATH)
+  db.pragma('journal_mode = WAL')
+  db.pragma('foreign_keys = ON')
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS elements (
+      id             TEXT PRIMARY KEY,
+      type           TEXT NOT NULL,
+      x              REAL NOT NULL,
+      y              REAL NOT NULL,
+      width          REAL NOT NULL,
+      height         REAL NOT NULL,
+      data           TEXT NOT NULL DEFAULT '{}',
+      zone_id        TEXT,
+      expansion_mode TEXT NOT NULL DEFAULT 'inline',
+      expanded       INTEGER NOT NULL DEFAULT 0,
+      state          TEXT NOT NULL DEFAULT 'default',
+      created_at     INTEGER NOT NULL,
+      updated_at     INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS links (
+      id              TEXT PRIMARY KEY,
+      from_element_id TEXT NOT NULL REFERENCES elements(id) ON DELETE CASCADE,
+      from_port_key   TEXT NOT NULL,
+      to_element_id   TEXT NOT NULL REFERENCES elements(id) ON DELETE CASCADE,
+      to_port_key     TEXT NOT NULL,
+      type            TEXT NOT NULL,
+      created_at      INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS zones (
+      id         TEXT PRIMARY KEY,
+      name       TEXT NOT NULL,
+      x          REAL NOT NULL,
+      y          REAL NOT NULL,
+      width      REAL NOT NULL,
+      height     REAL NOT NULL,
+      color      TEXT NOT NULL DEFAULT '#3b82f6',
+      config     TEXT NOT NULL DEFAULT '{}',
+      collapsed  INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS zone_inputs (
+      id        TEXT PRIMARY KEY,
+      zone_id   TEXT NOT NULL REFERENCES zones(id) ON DELETE CASCADE,
+      key       TEXT NOT NULL,
+      label     TEXT NOT NULL,
+      data_type TEXT NOT NULL DEFAULT 'any'
+    );
+
+    CREATE TABLE IF NOT EXISTS zone_input_links (
+      id            TEXT PRIMARY KEY,
+      zone_input_id TEXT NOT NULL REFERENCES zone_inputs(id) ON DELETE CASCADE,
+      element_id    TEXT NOT NULL,
+      port_key      TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS views (
+      id         TEXT PRIMARY KEY,
+      name       TEXT NOT NULL,
+      camera_x   REAL NOT NULL,
+      camera_y   REAL NOT NULL,
+      zoom       REAL NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS archive (
+      id           TEXT PRIMARY KEY,
+      element_data TEXT NOT NULL,
+      archived_at  INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS deleted (
+      id           TEXT PRIMARY KEY,
+      element_data TEXT NOT NULL,
+      deleted_at   INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS board_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS shapes (
+      id           TEXT PRIMARY KEY,
+      subtype      TEXT NOT NULL DEFAULT 'rectangle',
+      x            REAL NOT NULL,
+      y            REAL NOT NULL,
+      width        REAL NOT NULL,
+      height       REAL NOT NULL,
+      fill_color   TEXT NOT NULL DEFAULT 'transparent',
+      stroke_color TEXT NOT NULL DEFAULT '#6b7280',
+      stroke_width REAL NOT NULL DEFAULT 1.5,
+      text         TEXT NOT NULL DEFAULT '',
+      title        TEXT NOT NULL DEFAULT '',
+      text_align   TEXT NOT NULL DEFAULT 'center',
+      created_at   INTEGER NOT NULL,
+      updated_at   INTEGER NOT NULL
+    );
+  `)
+
+  // Seed board_meta if empty
+  const metaCount = db.prepare('SELECT COUNT(*) as c FROM board_meta').get()
+  if (metaCount.c === 0) {
+    const now = Date.now().toString()
+    db.prepare("INSERT INTO board_meta (key, value) VALUES ('created_at', ?)").run(now)
+    db.prepare("INSERT INTO board_meta (key, value) VALUES ('first_opened', 'false')").run()
+    db.prepare("INSERT INTO board_meta (key, value) VALUES ('projectDir', ?)").run(PROJECT_DIR)
+  }
+
+  _prepareStatements()
+}
+
+// Prepared statements
+let stmts = {}
+
+function _prepareStatements() {
+  stmts = {
+    // Elements
+    getElements:   db.prepare('SELECT * FROM elements'),
+    getElementById: db.prepare('SELECT * FROM elements WHERE id = ?'),
+    insertElement: db.prepare(`
+      INSERT INTO elements (id, type, x, y, width, height, data, zone_id, expansion_mode, expanded, state, created_at, updated_at)
+      VALUES (@id, @type, @x, @y, @width, @height, @data, @zone_id, @expansion_mode, @expanded, @state, @created_at, @updated_at)
+    `),
+    updateElement: db.prepare(`
+      UPDATE elements SET x=@x, y=@y, width=@width, height=@height, data=@data,
+        zone_id=@zone_id, expansion_mode=@expansion_mode, expanded=@expanded,
+        state=@state, updated_at=@updated_at
+      WHERE id=@id
+    `),
+    deleteElement: db.prepare('DELETE FROM elements WHERE id = ?'),
+
+    // Links
+    getLinks:     db.prepare('SELECT * FROM links'),
+    insertLink:   db.prepare(`
+      INSERT INTO links (id, from_element_id, from_port_key, to_element_id, to_port_key, type, created_at)
+      VALUES (@id, @from_element_id, @from_port_key, @to_element_id, @to_port_key, @type, @created_at)
+    `),
+    deleteLink:   db.prepare('DELETE FROM links WHERE id = ?'),
+
+    // Zones
+    getZones:     db.prepare('SELECT * FROM zones'),
+    insertZone:   db.prepare(`
+      INSERT INTO zones (id, name, x, y, width, height, color, config, collapsed, created_at, updated_at)
+      VALUES (@id, @name, @x, @y, @width, @height, @color, @config, @collapsed, @created_at, @updated_at)
+    `),
+    updateZone:   db.prepare(`
+      UPDATE zones SET name=@name, x=@x, y=@y, width=@width, height=@height,
+        color=@color, config=@config, collapsed=@collapsed, updated_at=@updated_at
+      WHERE id=@id
+    `),
+    deleteZone:   db.prepare('DELETE FROM zones WHERE id = ?'),
+
+    // Views
+    getViews:     db.prepare('SELECT * FROM views'),
+    insertView:   db.prepare(`
+      INSERT INTO views (id, name, camera_x, camera_y, zoom, created_at)
+      VALUES (@id, @name, @camera_x, @camera_y, @zoom, @created_at)
+    `),
+    deleteView:   db.prepare('DELETE FROM views WHERE id = ?'),
+
+    // Archive
+    getArchive:      db.prepare('SELECT * FROM archive ORDER BY archived_at DESC'),
+    insertArchive:   db.prepare('INSERT INTO archive (id, element_data, archived_at) VALUES (@id, @element_data, @archived_at)'),
+    removeArchive:   db.prepare('DELETE FROM archive WHERE id = ?'),
+
+    // Deleted
+    getDeleted:      db.prepare('SELECT * FROM deleted ORDER BY deleted_at DESC'),
+    insertDeleted:   db.prepare('INSERT INTO deleted (id, element_data, deleted_at) VALUES (@id, @element_data, @deleted_at)'),
+    removeDeleted:   db.prepare('DELETE FROM deleted WHERE id = ?'),
+
+    // Meta
+    getMeta:      db.prepare('SELECT value FROM board_meta WHERE key = ?'),
+    setMeta:      db.prepare('INSERT INTO board_meta (key, value) VALUES (@key, @value) ON CONFLICT(key) DO UPDATE SET value=@value'),
+
+    // Shapes
+    getShapes:    db.prepare('SELECT * FROM shapes ORDER BY created_at ASC'),
+    insertShape:  db.prepare(`
+      INSERT INTO shapes (id, subtype, x, y, width, height, fill_color, stroke_color, stroke_width, text, title, text_align, created_at, updated_at)
+      VALUES (@id, @subtype, @x, @y, @width, @height, @fill_color, @stroke_color, @stroke_width, @text, @title, @text_align, @created_at, @updated_at)
+    `),
+    updateShape:  db.prepare(`
+      UPDATE shapes SET subtype=@subtype, x=@x, y=@y, width=@width, height=@height,
+        fill_color=@fill_color, stroke_color=@stroke_color, stroke_width=@stroke_width,
+        text=@text, title=@title, text_align=@text_align, updated_at=@updated_at
+      WHERE id=@id
+    `),
+    deleteShape:  db.prepare('DELETE FROM shapes WHERE id = ?'),
+  }
+}
+
+// Helper: row → BoardElement
+function rowToElement(row) {
+  return {
+    id:            row.id,
+    type:          row.type,
+    x:             row.x,
+    y:             row.y,
+    width:         row.width,
+    height:        row.height,
+    data:          JSON.parse(row.data),
+    zoneId:        row.zone_id,
+    expansionMode: row.expansion_mode,
+    expanded:      row.expanded === 1,
+    state:         row.state,
+    createdAt:     row.created_at,
+    updatedAt:     row.updated_at,
+  }
+}
+
+// Helper: row → Link
+function rowToLink(row) {
+  return {
+    id:            row.id,
+    fromElementId: row.from_element_id,
+    fromPortKey:   row.from_port_key,
+    toElementId:   row.to_element_id,
+    toPortKey:     row.to_port_key,
+    type:          row.type,
+    createdAt:     row.created_at,
+  }
+}
+
+// Helper: row → Zone
+function rowToZone(row) {
+  return {
+    id:        row.id,
+    name:      row.name,
+    x:         row.x,
+    y:         row.y,
+    width:     row.width,
+    height:    row.height,
+    color:     row.color,
+    config:    JSON.parse(row.config),
+    collapsed: row.collapsed === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  }
+}
+
+// Helper: row → SavedView
+function rowToView(row) {
+  return {
+    id:        row.id,
+    name:      row.name,
+    cameraX:   row.camera_x,
+    cameraY:   row.camera_y,
+    zoom:      row.zoom,
+    createdAt: row.created_at,
+  }
+}
+
+// Helper: row → BinItem
+function rowToBinItem(row, timestampField) {
+  return {
+    id:          row.id,
+    elementData: JSON.parse(row.element_data),
+    timestamp:   row[timestampField],
+  }
+}
+
+// Exported DB helpers
+function dbGetElements()       { return stmts.getElements.all().map(rowToElement) }
+function dbGetElement(id)      { const r = stmts.getElementById.get(id); return r ? rowToElement(r) : null }
+
+function dbInsertElement(el) {
+  stmts.insertElement.run({
+    id:             el.id,
+    type:           el.type,
+    x:              el.x,
+    y:              el.y,
+    width:          el.width,
+    height:         el.height,
+    data:           JSON.stringify(el.data || {}),
+    zone_id:        el.zoneId || null,
+    expansion_mode: el.expansionMode || 'inline',
+    expanded:       el.expanded ? 1 : 0,
+    state:          el.state || 'default',
+    created_at:     el.createdAt,
+    updated_at:     el.updatedAt,
+  })
+}
+
+function dbUpdateElement(id, el) {
+  stmts.updateElement.run({
+    id,
+    x:              el.x,
+    y:              el.y,
+    width:          el.width,
+    height:         el.height,
+    data:           JSON.stringify(el.data || {}),
+    zone_id:        el.zoneId || null,
+    expansion_mode: el.expansionMode || 'inline',
+    expanded:       el.expanded ? 1 : 0,
+    state:          el.state || 'default',
+    updated_at:     el.updatedAt,
+  })
+}
+
+function dbDeleteElement(id)   { stmts.deleteElement.run(id) }
+
+function dbGetLinks()          { return stmts.getLinks.all().map(rowToLink) }
+
+function dbInsertLink(link) {
+  stmts.insertLink.run({
+    id:              link.id,
+    from_element_id: link.fromElementId,
+    from_port_key:   link.fromPortKey,
+    to_element_id:   link.toElementId,
+    to_port_key:     link.toPortKey,
+    type:            link.type,
+    created_at:      link.createdAt,
+  })
+}
+
+function dbDeleteLink(id)      { stmts.deleteLink.run(id) }
+
+function dbGetZones()          { return stmts.getZones.all().map(rowToZone) }
+
+function dbInsertZone(zone) {
+  stmts.insertZone.run({
+    id:         zone.id,
+    name:       zone.name,
+    x:          zone.x,
+    y:          zone.y,
+    width:      zone.width,
+    height:     zone.height,
+    color:      zone.color || '#3b82f6',
+    config:     JSON.stringify(zone.config || {}),
+    collapsed:  zone.collapsed ? 1 : 0,
+    created_at: zone.createdAt,
+    updated_at: zone.updatedAt,
+  })
+}
+
+function dbUpdateZone(id, zone) {
+  stmts.updateZone.run({
+    id,
+    name:       zone.name,
+    x:          zone.x,
+    y:          zone.y,
+    width:      zone.width,
+    height:     zone.height,
+    color:      zone.color || '#3b82f6',
+    config:     JSON.stringify(zone.config || {}),
+    collapsed:  zone.collapsed ? 1 : 0,
+    updated_at: zone.updatedAt,
+  })
+}
+
+function dbDeleteZone(id)      { stmts.deleteZone.run(id) }
+
+function dbGetViews()          { return stmts.getViews.all().map(rowToView) }
+
+function dbInsertView(v) {
+  stmts.insertView.run({
+    id:         v.id,
+    name:       v.name,
+    camera_x:   v.cameraX,
+    camera_y:   v.cameraY,
+    zoom:       v.zoom,
+    created_at: v.createdAt,
+  })
+}
+
+function dbDeleteView(id)      { stmts.deleteView.run(id) }
+
+function dbGetArchive()        { return stmts.getArchive.all().map(r => rowToBinItem(r, 'archived_at')) }
+
+function dbInsertArchive(item) {
+  stmts.insertArchive.run({
+    id:           item.id,
+    element_data: JSON.stringify(item.elementData),
+    archived_at:  item.timestamp,
+  })
+}
+
+function dbRemoveArchive(id)   { stmts.removeArchive.run(id) }
+
+function dbGetDeleted()        { return stmts.getDeleted.all().map(r => rowToBinItem(r, 'deleted_at')) }
+
+function dbInsertDeleted(item) {
+  stmts.insertDeleted.run({
+    id:           item.id,
+    element_data: JSON.stringify(item.elementData),
+    deleted_at:   item.timestamp,
+  })
+}
+
+function dbRemoveDeleted(id)   { stmts.removeDeleted.run(id) }
+
+function dbGetMeta(key)        { const r = stmts.getMeta.get(key); return r ? r.value : null }
+function dbSetMeta(key, value) { stmts.setMeta.run({ key, value }) }
+
+// Helper: row → BoardShape
+function rowToShape(row) {
+  return {
+    id:          row.id,
+    subtype:     row.subtype,
+    x:           row.x,
+    y:           row.y,
+    width:       row.width,
+    height:      row.height,
+    fillColor:   row.fill_color,
+    strokeColor: row.stroke_color,
+    strokeWidth: row.stroke_width,
+    text:        row.text,
+    title:       row.title,
+    textAlign:   row.text_align,
+    createdAt:   row.created_at,
+    updatedAt:   row.updated_at,
+  }
+}
+
+function dbGetShapes()      { return stmts.getShapes.all().map(rowToShape) }
+
+function dbInsertShape(s) {
+  stmts.insertShape.run({
+    id:           s.id,
+    subtype:      s.subtype      || 'rectangle',
+    x:            s.x,
+    y:            s.y,
+    width:        s.width,
+    height:       s.height,
+    fill_color:   s.fillColor   || 'transparent',
+    stroke_color: s.strokeColor || '#6b7280',
+    stroke_width: s.strokeWidth ?? 1.5,
+    text:         s.text        || '',
+    title:        s.title       || '',
+    text_align:   s.textAlign   || 'center',
+    created_at:   s.createdAt,
+    updated_at:   s.updatedAt,
+  })
+}
+
+function dbUpdateShape(id, s) {
+  stmts.updateShape.run({
+    id,
+    subtype:      s.subtype      || 'rectangle',
+    x:            s.x,
+    y:            s.y,
+    width:        s.width,
+    height:       s.height,
+    fill_color:   s.fillColor   || 'transparent',
+    stroke_color: s.strokeColor || '#6b7280',
+    stroke_width: s.strokeWidth ?? 1.5,
+    text:         s.text        || '',
+    title:        s.title       || '',
+    text_align:   s.textAlign   || 'center',
+    updated_at:   s.updatedAt,
+  })
+}
+
+function dbDeleteShape(id)  { stmts.deleteShape.run(id) }
+
+module.exports = {
+  initDB,
+  get db() { return db },
+  dbGetElements, dbGetElement, dbInsertElement, dbUpdateElement, dbDeleteElement,
+  dbGetLinks, dbInsertLink, dbDeleteLink,
+  dbGetZones, dbInsertZone, dbUpdateZone, dbDeleteZone,
+  dbGetViews, dbInsertView, dbDeleteView,
+  dbGetArchive, dbInsertArchive, dbRemoveArchive,
+  dbGetDeleted, dbInsertDeleted, dbRemoveDeleted,
+  dbGetMeta, dbSetMeta,
+  dbGetShapes, dbInsertShape, dbUpdateShape, dbDeleteShape,
+}

package/server/utils/element-instances.js

@@ -0,0 +1,104 @@
+'use strict'
+
+const { getElementType } = require('./element-registry.js')
+const boardState = require('./board-state.js')
+const { veilGet, veilPost, veilPut, veilDelete } = require('./veil-client.js')
+const { getIO } = require('./socket-io.js')
+
+const instances = new Map()
+
+function _buildContext(element) {
+  return {
+    element,
+    board: {
+      getElements: () => boardState.getElements(),
+      getLinks:    () => boardState.getLinks(),
+      getZones:    () => boardState.getZones(),
+    },
+    links: boardState.getLinks().filter(
+      l => l.fromElementId === element.id || l.toElementId === element.id
+    ),
+    zone: element.zoneId
+      ? boardState.getZones().find(z => z.id === element.zoneId) || null
+      : null,
+    veil: { get: veilGet, post: veilPost, put: veilPut, delete: veilDelete },
+    emit: (event, data) => {
+      try { getIO().emit(event, data) } catch (_) {}
+    },
+    log: (msg) => console.log(`[${element.type}:${element.id.slice(0, 8)}] ${msg}`),
+  }
+}
+
+function createInstance(element) {
+  const def = getElementType(element.type)
+  if (!def || typeof def.createInstance !== 'function') return null
+
+  try {
+    const ctx = _buildContext(element)
+    const instance = def.createInstance(ctx)
+    instances.set(element.id, instance)
+    return instance
+  } catch (err) {
+    console.error(`[element-instances] Failed to create instance for ${element.type}:${element.id}:`, err.message)
+    return null
+  }
+}
+
+function getInstance(elementId) {
+  return instances.get(elementId) || null
+}
+
+async function destroyInstance(elementId) {
+  const instance = instances.get(elementId)
+  if (!instance) return
+  try {
+    if (typeof instance.onDestroy === 'function') await instance.onDestroy()
+  } catch (err) {
+    console.error(`[element-instances] onDestroy error for ${elementId}:`, err.message)
+  }
+  instances.delete(elementId)
+}
+
+async function invokeAction(elementId, action, params) {
+  const instance = instances.get(elementId)
+  if (!instance) throw new Error(`No instance for element: ${elementId}`)
+  if (!instance.actions || typeof instance.actions[action] !== 'function') {
+    throw new Error(`Action "${action}" not found on element ${elementId}`)
+  }
+  return instance.actions[action](params)
+}
+
+function getViewData(elementId) {
+  const instance = instances.get(elementId)
+  if (!instance || typeof instance.getViewData !== 'function') return {}
+  try { return instance.getViewData() } catch (_) { return {} }
+}
+
+function getPorts(elementId) {
+  const instance = instances.get(elementId)
+  if (!instance || typeof instance.getPorts !== 'function') return []
+  try { return instance.getPorts() } catch (_) { return [] }
+}
+
+function recreateInstance(element) {
+  destroyInstance(element.id)
+  return createInstance(element)
+}
+
+function initAllInstances() {
+  const elements = boardState.getElements()
+  for (const el of elements) {
+    if (!instances.has(el.id)) createInstance(el)
+  }
+}
+
+module.exports = {
+  getInstance,
+  createInstance,
+  destroyInstance,
+  invokeAction,
+  getViewData,
+  getPorts,
+  recreateInstance,
+  initAllInstances,
+}

package/server/utils/element-registry.js

@@ -0,0 +1,127 @@
+'use strict'
+
+const path = require('path')
+const fs = require('fs')
+const { ELEMENTS_DIR } = require('./config.js')
+
+const builtins = new Map()
+const customs  = new Map()
+
+function registerBuiltin(def) {
+  builtins.set(def.type, def)
+}
+
+function getElementType(type) {
+  return customs.get(type) || builtins.get(type) || null
+}
+
+function getAllTypes() {
+  const result = new Map(builtins)
+  for (const [k, v] of customs) result.set(k, v)
+  return Array.from(result.values()).map(def => ({
+    type:           def.type,
+    name:           def.name,
+    description:    def.description,
+    icon:           def.icon,
+    defaultWidth:   def.defaultWidth,
+    defaultHeight:  def.defaultHeight,
+    expansionMode:  def.expansionMode,
+    tags:           def.tags || [],
+    isBuiltIn:         def.isBuiltIn !== false,
+    hiddenFromPalette: def.hiddenFromPalette === true,
+    componentSource:   def.componentSource || undefined,
+  }))
+}
+
+function loadCustomElements() {
+  customs.clear()
+  if (!fs.existsSync(ELEMENTS_DIR)) return
+
+  let entries
+  try {
+    entries = fs.readdirSync(ELEMENTS_DIR, { withFileTypes: true })
+  } catch (_) { return }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const typeDir  = path.join(ELEMENTS_DIR, entry.name)
+    const metaPath = path.join(typeDir, 'element.json')
+    const idxPath  = path.join(typeDir, 'index.js')
+    const vuePath  = path.join(typeDir, 'vue-component.js')
+
+    if (!fs.existsSync(metaPath) || !fs.existsSync(idxPath)) continue
+
+    try {
+      const meta   = JSON.parse(fs.readFileSync(metaPath, 'utf8'))
+      const factory = require(idxPath)
+      const componentSource = fs.existsSync(vuePath)
+        ? fs.readFileSync(vuePath, 'utf8')
+        : undefined
+
+      customs.set(meta.type, {
+        ...meta,
+        isBuiltIn: false,
+        createInstance: factory.createInstance,
+        componentSource,
+      })
+    } catch (err) {
+      console.error(`[element-registry] Failed to load custom element "${entry.name}":`, err.message)
+    }
+  }
+}
+
+function reloadCustomElements() {
+  // Clear require cache for custom elements
+  if (fs.existsSync(ELEMENTS_DIR)) {
+    try {
+      const entries = fs.readdirSync(ELEMENTS_DIR, { withFileTypes: true })
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        const idxPath = path.join(ELEMENTS_DIR, entry.name, 'index.js')
+        if (require.cache[idxPath]) delete require.cache[idxPath]
+      }
+    } catch (_) {}
+  }
+  loadCustomElements()
+}
+
+function getClientComponentDefinitions() {
+  return Array.from(customs.values())
+    .filter(def => def.componentSource)
+    .map(def => ({ type: def.type, componentSource: def.componentSource }))
+}
+
+// ─── Register all built-in element types ────────────────────────────────────
+
+const ELEMENTS_SERVER_DIR = path.join(__dirname, 'elements')
+
+const BUILTIN_TYPES = [
+  'agent', 'agent-instance', 'chat-view', 'task', 'todo-list',
+  'text', 'markdown', 'code-block', 'json-object', 'html', 'file-reference', 'image', 'image-local', 'url-card', 'web-snapshot',
+  'source-collection', 'research-note', 'comparison-table', 'fact-claim', 'question', 'web-search-query',
+  'document-draft', 'outline', 'section', 'template',
+  'diff-patch', 'notification', 'test-case',
+  'idea', 'pro-con-list', 'decision', 'assumption', 'constraint', 'goal', 'blocker',
+  'project', 'milestone', 'status-update',
+  'chat-room', 'message', 'feedback-request', 'approval-gate',
+  'generator', 'processor', 'splitter', 'merger', 'filter', 'queue',
+  'collapsible-group', 'annotation', 'label-tag', 'divider',
+]
+
+for (const type of BUILTIN_TYPES) {
+  try {
+    const def = require(path.join(ELEMENTS_SERVER_DIR, `${type}.js`))
+    registerBuiltin(def)
+  } catch (err) {
+    console.error(`[element-registry] Failed to load built-in "${type}":`, err.message)
+  }
+}
+
+module.exports = {
+  registerBuiltin,
+  getElementType,
+  getAllTypes,
+  loadCustomElements,
+  reloadCustomElements,
+  getClientComponentDefinitions,
+}