acrylblends 1.1.0 → 1.3.0

package/plugins/feedback/store.ts

@@ -0,0 +1,307 @@
+/**
+ * The notes people sent, in the app's own data: one JSON line per note in `notes.jsonl`, the ids the builder has seen in `seen.json`, and a note's
+ * screenshot as a file in `shots/`. Appending never rewrites a note, so a crash loses at most the note being written; an image is written before its
+ * note, so a note never names a missing file.
+ */
+import { randomUUID } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+/** The element a note was pinned on: a CSS selector to find it again, and a short name to show. */
+export interface PinnedElement {
+  readonly selector: string
+  readonly label: string
+}
+
+export type ScreenshotMediaType = 'image/webp' | 'image/png'
+
+/** A note's screenshot, as stored beside the notes. */
+export interface FeedbackScreenshot {
+  /** The file under `shots/`. */
+  readonly file: string
+  readonly mediaType: ScreenshotMediaType
+  readonly width: number
+  readonly height: number
+  readonly bytes: number
+}
+
+/**
+ * A note already pinned on an element of a page, as that page's own script sees it: where to find the element again and the number its badge
+ * shows. It carries no note text, because anyone who opens the page can read this.
+ */
+export interface FeedbackPin {
+  readonly selector: string
+  readonly number: number
+}
+
+export interface FeedbackNote {
+  readonly id: string
+  /** ISO time it was sent. */
+  readonly at: string
+  readonly text: string
+  /** The page's path (and query) it was sent from. */
+  readonly page: string
+  /** Absent for "Nothing specific". */
+  readonly element?: PinnedElement
+  /** What the person saw when they sent it; absent when the browser refused the capture. */
+  readonly screenshot?: FeedbackScreenshot
+  /** The builder has seen it in the frame. */
+  readonly seen: boolean
+}
+
+/** One screenshot as the page sent it, decoded and checked. */
+export interface NewScreenshot {
+  readonly mediaType: ScreenshotMediaType
+  readonly width: number
+  readonly height: number
+  readonly data: Buffer
+}
+
+export interface NewNote {
+  readonly text: string
+  readonly page: string
+  readonly element?: PinnedElement
+  readonly screenshot?: NewScreenshot
+}
+
+/** A stored screenshot's bytes and type. */
+export interface StoredScreenshot {
+  readonly bytes: Buffer
+  readonly mediaType: ScreenshotMediaType
+}
+
+export const LIMITS = {
+  text: 2000,
+  page: 500,
+  selector: 500,
+  label: 120,
+  /** Decoded image bytes; the page downscales and re-encodes below this. */
+  screenshotBytes: 512 * 1024,
+  screenshotSide: 2000,
+} as const
+
+const DATA_URL = /^data:(image\/(?:webp|png));base64,([A-Za-z0-9+/]+={0,2})$/u
+const NOTE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u
+
+/** One screenshot from the page: a WebP or PNG data URL, its size, and the bytes. A string says what is wrong. */
+export function parseScreenshot(value: unknown): NewScreenshot | string {
+  if (typeof value !== 'object' || value === null) return 'the screenshot must be an object'
+  const { data, width, height } = value as Record<string, unknown>
+  if (typeof data !== 'string') return 'the screenshot has no image'
+  const match = DATA_URL.exec(data)
+  if (match === null || match[1] === undefined || match[2] === undefined)
+    return 'the screenshot must be a WebP or PNG data URL'
+  const mediaType = match[1] as ScreenshotMediaType
+  const bytes = Buffer.from(match[2], 'base64')
+  if (bytes.length === 0) return 'the screenshot is empty'
+  if (bytes.length > LIMITS.screenshotBytes)
+    return `a screenshot is at most ${String(Math.round(LIMITS.screenshotBytes / 1024))} KB`
+  const webp =
+    bytes.subarray(0, 4).toString() === 'RIFF' && bytes.subarray(8, 12).toString() === 'WEBP'
+  const png = bytes[0] === 0x89 && bytes.subarray(1, 4).toString() === 'PNG'
+  if ((mediaType === 'image/webp' && !webp) || (mediaType === 'image/png' && !png))
+    return 'the screenshot is not the image its type names'
+  if (
+    !Number.isInteger(width) ||
+    !Number.isInteger(height) ||
+    (width as number) < 1 ||
+    (height as number) < 1 ||
+    (width as number) > LIMITS.screenshotSide ||
+    (height as number) > LIMITS.screenshotSide
+  )
+    return `the screenshot needs its size, up to ${String(LIMITS.screenshotSide)} px a side`
+  return { mediaType, width: width as number, height: height as number, data: bytes }
+}
+
+/** A note as a page sent it, checked; a string says what is wrong. */
+export function parseNewNote(body: unknown): NewNote | string {
+  if (body === null || typeof body !== 'object') return 'send a JSON object'
+  const { text, page, element, screenshot } = body as Record<string, unknown>
+  if (typeof text !== 'string' || text.trim() === '') return 'write a note'
+  if (text.length > LIMITS.text) return `a note has at most ${LIMITS.text} characters`
+  if (typeof page !== 'string' || !page.startsWith('/') || page.length > LIMITS.page)
+    return 'the page must be a path'
+  let pinned: PinnedElement | undefined
+  if (element !== undefined && element !== null) {
+    if (typeof element !== 'object') return 'the element must be an object'
+    const { selector, label } = element as Record<string, unknown>
+    if (typeof selector !== 'string' || selector === '' || selector.length > LIMITS.selector)
+      return 'the element needs a selector'
+    if (typeof label !== 'string' || label === '' || label.length > LIMITS.label)
+      return 'the element needs a name'
+    pinned = { selector, label }
+  }
+  let shot: NewScreenshot | undefined
+  if (screenshot !== undefined && screenshot !== null) {
+    const parsed = parseScreenshot(screenshot)
+    if (typeof parsed === 'string') return parsed
+    shot = parsed
+  }
+  return {
+    text: text.trim(),
+    page,
+    ...(pinned === undefined ? {} : { element: pinned }),
+    ...(shot === undefined ? {} : { screenshot: shot }),
+  }
+}
+
+function storedScreenshot(raw: unknown): FeedbackScreenshot | undefined {
+  if (raw === null || typeof raw !== 'object') return undefined
+  const { file, mediaType, width, height, bytes } = raw as Record<string, unknown>
+  if (
+    typeof file !== 'string' ||
+    (mediaType !== 'image/webp' && mediaType !== 'image/png') ||
+    !Number.isInteger(width) ||
+    !Number.isInteger(height) ||
+    !Number.isInteger(bytes)
+  )
+    return undefined
+  return {
+    file,
+    mediaType,
+    width: width as number,
+    height: height as number,
+    bytes: bytes as number,
+  }
+}
+
+export class FeedbackStore {
+  private readonly notesFile: string
+  private readonly seenFile: string
+  private readonly shotsDir: string
+  /** Writes one after another, so two notes never interleave in the file. */
+  private queue: Promise<unknown> = Promise.resolve()
+
+  constructor(dir: string) {
+    this.notesFile = join(dir, 'notes.jsonl')
+    this.seenFile = join(dir, 'seen.json')
+    this.shotsDir = join(dir, 'shots')
+  }
+
+  add(note: NewNote, now: Date = new Date()): Promise<FeedbackNote> {
+    const id = randomUUID()
+    const shot = note.screenshot
+    const stored = {
+      id,
+      at: now.toISOString(),
+      text: note.text,
+      page: note.page,
+      ...(note.element === undefined ? {} : { element: note.element }),
+      ...(shot === undefined
+        ? {}
+        : {
+            screenshot: {
+              file: `${id}.${shot.mediaType === 'image/webp' ? 'webp' : 'png'}`,
+              mediaType: shot.mediaType,
+              width: shot.width,
+              height: shot.height,
+              bytes: shot.data.length,
+            },
+          }),
+    }
+    return this.serial(async () => {
+      await mkdir(join(this.notesFile, '..'), { recursive: true })
+      if (shot !== undefined) {
+        // The image first: a note in the file always has its screenshot.
+        await mkdir(this.shotsDir, { recursive: true })
+        await writeFile(
+          join(this.shotsDir, `${id}.${shot.mediaType === 'image/webp' ? 'webp' : 'png'}`),
+          shot.data,
+        )
+      }
+      await appendFile(this.notesFile, `${JSON.stringify(stored)}\n`)
+      return { ...stored, seen: false }
+    })
+  }
+
+  /** One note's screenshot, when it has one and the file is still there. */
+  async screenshot(id: string): Promise<StoredScreenshot | undefined> {
+    if (!NOTE_ID.test(id)) return undefined
+    for (const [ext, mediaType] of [
+      ['webp', 'image/webp'],
+      ['png', 'image/png'],
+    ] as const) {
+      try {
+        return { bytes: await readFile(join(this.shotsDir, `${id}.${ext}`)), mediaType }
+      } catch {
+        // Not this type; try the other.
+      }
+    }
+    return undefined
+  }
+
+  /**
+   * The pins of one page, for the badges its visitors see: the elements a note was pinned on, numbered in the order their first note came,
+   * oldest first. One pin per element, so two notes on the same element share its badge, and the number of a pin never moves once it is given.
+   */
+  async pins(page: string): Promise<FeedbackPin[]> {
+    const pins: FeedbackPin[] = []
+    const taken = new Set<string>()
+    for (const note of (await this.list()).reverse()) {
+      const element = note.element
+      if (note.page !== page || element === undefined || taken.has(element.selector)) continue
+      taken.add(element.selector)
+      pins.push({ selector: element.selector, number: pins.length + 1 })
+    }
+    return pins
+  }
+
+  /** Every note, newest first. A line that is not a note is skipped. */
+  async list(): Promise<FeedbackNote[]> {
+    if (!existsSync(this.notesFile)) return []
+    const seen = await this.seen()
+    const notes: FeedbackNote[] = []
+    for (const line of (await readFile(this.notesFile, 'utf8')).split('\n')) {
+      if (line.trim() === '') continue
+      try {
+        const raw = JSON.parse(line) as Omit<FeedbackNote, 'seen'> & {
+          readonly screenshot?: unknown
+        }
+        if (
+          typeof raw.id === 'string' &&
+          typeof raw.at === 'string' &&
+          typeof raw.text === 'string' &&
+          typeof raw.page === 'string'
+        ) {
+          const { screenshot, ...rest } = raw
+          const shot = storedScreenshot(screenshot)
+          notes.push({
+            ...rest,
+            seen: seen.has(raw.id),
+            ...(shot === undefined ? {} : { screenshot: shot }),
+          })
+        }
+      } catch {
+        // A torn last line: skipped.
+      }
+    }
+    return notes.reverse()
+  }
+
+  markSeen(ids: readonly string[]): Promise<void> {
+    return this.serial(async () => {
+      const seen = await this.seen()
+      for (const id of ids) seen.add(id)
+      await mkdir(join(this.seenFile, '..'), { recursive: true })
+      await writeFile(this.seenFile, JSON.stringify([...seen]))
+    })
+  }
+
+  private async seen(): Promise<Set<string>> {
+    try {
+      const ids: unknown = JSON.parse(await readFile(this.seenFile, 'utf8'))
+      return new Set(
+        Array.isArray(ids) ? ids.filter((id): id is string => typeof id === 'string') : [],
+      )
+    } catch {
+      return new Set()
+    }
+  }
+
+  private serial<T>(work: () => Promise<T>): Promise<T> {
+    const next = this.queue.then(work, work)
+    this.queue = next.catch(() => {})
+    return next
+  }
+}

package/plugins/home/index.ts

@@ -0,0 +1,122 @@
+/**
+ * The app's home page as a place plugins put their widgets (`ctx.home`).
+ *
+ * A feature is its own plugin, so its UI must reach the page without anyone editing the page's code: a plugin registers a widget, the home page
+ * renders every widget registered at the time of the request, and the widget leaves the page with the plugin that registered it (switched off in
+ * Settings > Plugins, removed, or reloaded). The widget is HTML rendered into the page itself, not a frame, so the page, its tests and the door's
+ * `look` all see it.
+ *
+ * A widget names its plugin's URLs as the app's own server answers them (`/notes/widget.js`, `fetch('/notes/items')`): on `npm start` they are at the
+ * root, and in the frame the canvas page sends them to the same routes under its prefix.
+ */
+import type { Context } from '@deepseek-ai/cordis'
+
+/** One widget on the home page. */
+export interface HomeWidget {
+  /** Unique on the page: the name of the plugin that registers it. */
+  readonly id: string
+  /** The widget's heading; the page escapes it. */
+  readonly title: string
+  /** The widget's HTML, rendered into the page at each request. It is inserted as it is: escape any user text in it. */
+  render(): string | Promise<string>
+}
+
+export interface Home {
+  /**
+   * Put a widget on the home page. Call it inside `ctx.effect` so the widget leaves with the plugin:
+   * `ctx.effect(() => ctx.home.widget({ id: 'notes', title: 'Notes', render: () => '<div id="notes"></div>' }))`.
+   * @returns the disposer, which takes the widget off the page.
+   * @throws when a widget with the same id is already on the page.
+   */
+  widget(widget: HomeWidget): () => void
+  /** The widgets on the page now, in the order they were registered. */
+  widgets(): readonly HomeWidget[]
+}
+
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    home: Home
+  }
+}
+
+const ID = /^[a-z0-9][a-z0-9-]*$/
+
+export function createHome(): Home {
+  const registered = new Map<string, HomeWidget>()
+  return {
+    widget(widget) {
+      if (!ID.test(widget.id))
+        throw new Error(
+          `a widget id is a plugin name (lowercase letters, digits and dashes), not "${widget.id}"`,
+        )
+      if (registered.has(widget.id))
+        throw new Error(`the home page already has a widget "${widget.id}"`)
+      registered.set(widget.id, widget)
+      return () => {
+        if (registered.get(widget.id) === widget) registered.delete(widget.id)
+      }
+    },
+    widgets: () => [...registered.values()],
+  }
+}
+
+const escapeHtml = (text: string): string =>
+  text
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+
+/**
+ * The widgets' look, the ACRYL frame's plain one: each widget a card, and the plain HTML a widget writes (a list, a form, inputs, buttons, an output)
+ * styled inside it, light or dark with the person's system. Every selector is under `.widget`, so the page around the widgets keeps its own styles,
+ * and a widget's own `<style>` still wins (it comes later on the page).
+ */
+export const WIDGET_STYLES = `.widget{--widget-bg:#fff;--widget-surface:#f7f7f9;--widget-border:#e2e2e8;--widget-text:#18181b;--widget-dim:#6b6b75;--widget-accent:#5468ff;--widget-accent-dim:rgba(84,104,255,.18);color-scheme:light;margin:16px 0;padding:16px 18px;border:1px solid var(--widget-border);border-radius:12px;background:var(--widget-surface);color:var(--widget-text);font:14px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif}
+@media (prefers-color-scheme:dark){.widget{--widget-bg:#0b0b0d;--widget-surface:#18181b;--widget-border:#2a2a2f;--widget-text:#e8e8ea;--widget-dim:#8b8b93;color-scheme:dark}}
+.widget h2{margin:0 0 12px;font-size:15px;font-weight:600}
+.widget p{margin:0 0 10px}
+.widget p:last-child,.widget ul:last-child,.widget ol:last-child,.widget form:last-child{margin-bottom:0}
+.widget ul,.widget ol{list-style:none;margin:0 0 12px;padding:0}
+.widget li{display:flex;align-items:center;gap:8px;padding:7px 0;border-top:1px solid var(--widget-border);overflow-wrap:anywhere}
+.widget li:first-child{border-top:0}
+.widget li>:last-child:is(button,form){margin-left:auto}
+.widget a{color:var(--widget-accent);text-decoration:none}
+.widget a:hover{text-decoration:underline}
+.widget form{display:flex;flex-wrap:wrap;gap:8px;margin:0 0 10px}
+.widget input,.widget textarea,.widget select{flex:1 1 140px;min-width:0;padding:7px 10px;border:1px solid var(--widget-border);border-radius:8px;background:var(--widget-bg);color:inherit;font:inherit}
+.widget input::placeholder,.widget textarea::placeholder{color:var(--widget-dim)}
+.widget input:focus,.widget textarea:focus,.widget select:focus{outline:2px solid var(--widget-accent-dim);border-color:var(--widget-accent)}
+.widget button{padding:7px 14px;border:0;border-radius:8px;background:var(--widget-accent);color:#fff;font:inherit;font-weight:500;cursor:pointer}
+.widget button:hover{filter:brightness(1.1)}
+.widget li button{flex:none;padding:3px 10px;border:1px solid var(--widget-border);background:transparent;color:var(--widget-dim);font-weight:400}
+.widget output{font-weight:600;font-variant-numeric:tabular-nums}
+.widget [role=alert]{color:#d9480f}`
+
+/**
+ * The widgets as one block of the page: their styles ({@link WIDGET_STYLES}), then a `<section data-widget="<id>">` with the heading and the
+ * widget's HTML for each; nothing at all when there is no widget. A widget whose render throws shows one line saying so, and the page still renders.
+ */
+export async function renderWidgets(home: Home): Promise<string> {
+  const sections = await Promise.all(
+    home.widgets().map(async (widget) => {
+      let body: string
+      try {
+        body = await widget.render()
+      } catch (cause) {
+        body = `<p role="alert">This widget could not be shown: ${escapeHtml(cause instanceof Error ? cause.message : String(cause))}</p>`
+      }
+      return `<section class="widget" data-widget="${escapeHtml(widget.id)}">\n<h2>${escapeHtml(widget.title)}</h2>\n${body}\n</section>`
+    }),
+  )
+  return sections.length === 0
+    ? ''
+    : [`<style data-home-widgets>${WIDGET_STYLES}</style>`, ...sections].join('\n')
+}
+
+/** Provides `ctx.home`. Mount it before the routes that render the home page and before the plugins that put widgets on it. */
+export const name = 'home'
+
+export function apply(ctx: Context): void {
+  ctx.provide('home', createHome())
+}

package/plugins/home/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "home",
+  "description": "The app's home page as a place plugins put their widgets: a plugin registers a widget in ctx.effect, the page renders it, and it leaves with the plugin.",
+  "requires": [],
+  "inject": [],
+  "provides": ["home"],
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.0.4"
+  },
+  "mount": "a row `- id: home` / `name: home` before the routes row in blend.yaml; the routes render renderWidgets(ctx.home) on the home page; a plugin does ctx.effect(() => ctx.home.widget({ id, title, render }))"
+}

package/plugins/instance/index.ts

@@ -30,6 +30,11 @@ export interface AppInstance {
   readonly root: string
   /** The app's own data: settings, installed extensions, the extension ledger. Never shared with another app. */
   readonly home: string
+  /**
+   * The host's engine home: where the engine keeps its own files, the logs included. ACRYL's plugins read it (the support download serves `dshHome/logs`);
+   * in this host the engine and the app share one home, so it equals `home`.
+   */
+  readonly dshHome: string
   readonly port: PortPreference
   /** The interface to listen on. Absent means loopback only; a container sets `0.0.0.0` so its published port reaches the app. */
   readonly host?: string
@@ -84,6 +89,7 @@ function family(input: {
     name: input.name,
     root: input.root,
     home: input.home,
+    dshHome: input.home,
     port: Object.freeze({ ...input.port }),
     runLockFile: join(input.home, RUN_LOCK_FILE),
   })

package/plugins/manifest/app-plugins.ts

@@ -0,0 +1,86 @@
+/**
+ * The app's own plugins: the folders of `plugins/` that are not library copies (`plugins/library.json` lists those). A feature is one of them, and
+ * `blend.yaml` mounts it with a row of its own (`- id: notes` / `name: notes`), with no import in `src/app.ts`: a row whose name the static registry
+ * does not have resolves to the folder of that name here. So `blend.yaml` plus `plugins/` is the whole composition, and a version, a shared app or a
+ * blueprint made from the folder starts the same plugins.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { basename, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+/** The file a plugin folder starts from, in the order they are looked for. */
+export const PLUGIN_ENTRIES = ['index.ts', 'index.js', 'index.mjs'] as const
+/** A plugin's name: its folder's name and its Loader row id. */
+const NAME = /^[a-z0-9][a-z0-9-]*$/
+
+/** The library copies a plugins folder holds (`library.json`, written by `acrylblends add`); absent or unreadable means none. */
+export function libraryCopies(dir: string): ReadonlySet<string> {
+  try {
+    const listed = (
+      JSON.parse(readFileSync(join(dir, 'library.json'), 'utf8')) as { plugins?: unknown }
+    ).plugins
+    return new Set(
+      Array.isArray(listed)
+        ? listed.filter((name): name is string => typeof name === 'string')
+        : [],
+    )
+  } catch {
+    return new Set()
+  }
+}
+
+/** The entry file of a plugin folder, or undefined when it has none. */
+export function pluginEntry(dir: string): string | undefined {
+  return PLUGIN_ENTRIES.map((file) => join(dir, file)).find((path) => existsSync(path))
+}
+
+/** The names of the app's own plugins in `dir` (the app's `plugins/`): folders with an entry file that are not library copies, sorted. */
+export function appPluginNames(dir: string): string[] {
+  if (!existsSync(dir)) return []
+  const library = libraryCopies(dir)
+  return readdirSync(dir, { withFileTypes: true })
+    .filter(
+      (entry) =>
+        entry.isDirectory() &&
+        NAME.test(entry.name) &&
+        !library.has(entry.name) &&
+        pluginEntry(join(dir, entry.name)) !== undefined,
+    )
+    .map((entry) => entry.name)
+    .sort()
+}
+
+/** A plugin module as a row mounts it. */
+export interface AppPluginModule {
+  readonly name: string
+  readonly apply: (...args: never[]) => unknown
+}
+
+/**
+ * Import the app's own plugins `names` from `dir`, each checked to be a Cordis plugin whose `name` is its folder's.
+ * @throws an error that names the folder and the fix, for a folder that does not export a plugin.
+ */
+export async function loadAppPlugins(
+  dir: string,
+  names: readonly string[],
+): Promise<Record<string, AppPluginModule>> {
+  const loaded: Record<string, AppPluginModule> = {}
+  for (const name of names) {
+    const entry = pluginEntry(join(dir, name))
+    if (entry === undefined) throw new Error(`plugins/${name} has no ${PLUGIN_ENTRIES.join(', ')}`)
+    const module = (await import(pathToFileURL(entry).href)) as Partial<AppPluginModule> & {
+      default?: Partial<AppPluginModule>
+    }
+    const plugin = typeof module.apply === 'function' ? module : module.default
+    if (plugin === undefined || typeof plugin.apply !== 'function')
+      throw new Error(
+        `plugins/${name}/${basename(entry)} must export a Cordis plugin: export const name = '${name}' and export function apply(ctx) { ... }`,
+      )
+    if (plugin.name !== undefined && plugin.name !== name)
+      throw new Error(
+        `plugins/${name} exports the plugin name "${String(plugin.name)}"; a plugin's name is its folder's, "${name}"`,
+      )
+    loaded[name] = { ...plugin, name } as AppPluginModule
+  }
+  return loaded
+}

package/plugins/manifest/index.ts

@@ -13,8 +13,9 @@
  *   which of this Blend's overrides and rows it breaks.
  *
  * Problems are diagnostics with a code and a path, never a bare "invalid". The code an app can use stays in `src/app.ts` as a static
- * registry of imports (so it type-checks); the manifest chooses, orders, configures and switches those plugins. Extensions are not
- * listed here: they come and go while the app runs.
+ * registry of imports (so it type-checks); the manifest chooses, orders, configures and switches those plugins. A row may also name one of the
+ * app's own plugin folders (`plugins/<name>/`, app-plugins.ts): that is how a feature is mounted. Extensions are not listed here: they come and go
+ * while the app runs.
  */
 import { createHash } from 'node:crypto'
 import { existsSync, readFileSync } from 'node:fs'
@@ -633,3 +634,12 @@ export function blueprintsIn(directory: string): (id: string) => string | undefi
     return DEFINITION_ID.test(id) && existsSync(file) ? file : undefined
   }
 }
+
+export {
+  type AppPluginModule,
+  appPluginNames,
+  libraryCopies,
+  loadAppPlugins,
+  PLUGIN_ENTRIES,
+  pluginEntry,
+} from './app-plugins.ts'

package/plugins/manifest/plugin.json

@@ -7,7 +7,7 @@
   "dependencies": {
     "@deepseek-ai/cordis": "4.0.4",
     "yaml": "2.9.0",
-    "@webboxes/blends-core": "0.4.0"
+    "@webboxes/blends-core": "0.5.0"
   },
   "mount": "in src/app.ts: const manifest = loadManifest(join(chosen.root, 'blend.yaml')); await compose(root, manifest, registry)"
 }