acrylblends 1.3.1 → 1.3.2

package/legacy/agent/ecbc84f1c1e5/src/app.ts

@@ -0,0 +1,291 @@
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import * as door from '../plugins/acryl-door/src/index.ts'
+import * as nodeServer from '../plugins/acryl-node-server/src/index.ts'
+import * as router from '../plugins/acryl-router/src/index.ts'
+import * as state from '../plugins/acryl-state/src/index.ts'
+import { agent, memory, model, scripted, tools } from '../plugins/agent/index.ts'
+import * as panel from '../plugins/agent-panel/index.ts'
+import { builder } from '../plugins/builder/index.ts'
+import { extensions } from '../plugins/extensions/index.ts'
+import { type AppInstance, instance } from '../plugins/instance/index.ts'
+import {
+  appPluginNames,
+  blueprintsIn,
+  compose,
+  loadAppPlugins,
+  loadManifest,
+  type ParameterValue,
+} from '../plugins/manifest/index.ts'
+import { ASSISTANT_PROMPT, type OpenAIConfig, openai } from '../plugins/openai/index.ts'
+import { pluginShare } from '../plugins/plugin-share/index.ts'
+import { sandboxPlugin } from '../plugins/sandbox/index.ts'
+import { save } from '../plugins/save/index.ts'
+import { tasks } from '../plugins/tasks/index.ts'
+import { FRAME_MOUNT_PREFIX, routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = {
+  tasks,
+  model,
+  tools,
+  memory,
+  agent,
+  'acryl-router': router,
+  'acryl-state': state,
+  extensions,
+  builder,
+  'plugin-share': pluginShare,
+  save,
+  sandbox: sandboxPlugin,
+  routes,
+  'acryl-node-server': nodeServer,
+  'agent-panel': panel,
+  'acryl-door': door,
+}
+
+/** The manifest next to this app's source. */
+export const MANIFEST = join(fileURLToPath(new URL('..', import.meta.url)), 'blend.yaml')
+/** The app's own plugins (a feature each), which `blend.yaml` mounts by their folder name next to the library copies `registry` imports. */
+const PLUGINS_DIR = join(fileURLToPath(new URL('..', import.meta.url)), 'plugins')
+
+/**
+ * The app's manifest, resolved. A Blend finds its Blueprint in `blueprints/<id>.yaml`; an app that is itself a Blueprint never looks.
+ * `createApp` and the tests read it the same way.
+ */
+export function readManifest(values?: Readonly<Record<string, ParameterValue>>) {
+  return loadManifest(MANIFEST, {
+    known: [...Object.keys(registry), ...appPluginNames(PLUGINS_DIR)],
+    getBlueprint: blueprintsIn(join(fileURLToPath(new URL('..', import.meta.url)), 'blueprints')),
+    ...(values ? { values } : {}),
+  })
+}
+
+export interface App {
+  readonly root: Context
+  /** The address the server listens on; empty when the app was made with `listen: false`. */
+  readonly url: string
+  stop(): Promise<void>
+}
+
+/**
+ * The development rows, and what each one gives a visitor. Production leaves the agent and the builder out. The extensions row is not left out: it starts again, read-only,
+ * the extensions in the app's `plugins/` folder (what the agent built and installed in development, committed with the app), so a deployed app has its own features; nothing
+ * can be installed, updated or approved while it runs, and `/ask`, `/extensions*` and `/tasks*` stay unmounted (they need the agent). `ACRYL_PRODUCTION_KEEP=extensions` keeps the
+ * live install itself.
+ */
+const DEVELOPMENT_ROWS: Record<string, string> = {
+  agent: 'POST /ask runs the agent, which spends the model key and calls its tools',
+  builder: 'the agent can write plugin source into plugins/',
+  'plugin-share': 'a plugin pulled from a release runs in this process',
+  extensions:
+    'a plugin installed live runs in this process, and POST /extensions/approve decides installs',
+}
+
+/** The only tools the production Assistant's agent may call: look at the page and act on it. */
+const ASSISTANT_TOOLS = ['door_look', 'door_act']
+
+/** The most tokens one answer of the Assistant's model may use: with the step budget, what one visitor's question can cost at most. */
+const ASSISTANT_MAX_TOKENS = 1024
+
+/** Model calls per visitor question: look, open a page, look, filter, look and answer is six, with room for one wrong turn. */
+const ASSISTANT_STEPS = 10
+
+/** What the Assistant says while the app has no model: the scripted one cannot use the page. */
+export const ASSISTANT_NO_MODEL =
+  "This assistant is not set up yet: the app's owner has not chosen a model for it."
+
+/**
+ * The app's rows in the manifest's order, composed into `ctx`: the app's own server calls this from `createApp`, and the generated frame layer mounts it
+ * as one row, so the frame runs the app exactly as the app's own server does (same rows, same order, same config). `host: true` leaves the server and the
+ * door to the frame host, which mounts its own.
+ */
+export async function composeInto(
+  ctx: Context,
+  chosen: AppInstance,
+  options: {
+    values?: Readonly<Record<string, ParameterValue>>
+    model?: OpenAIConfig
+    listen?: boolean
+    host?: boolean
+  } = {},
+): Promise<Fiber[]> {
+  const read = readManifest(options.values)
+  // Rows left out: the server (and so the door, which needs it) when the app is reached in process; the door in production and with ACRYL_DOOR=off (one process at a time
+  // serves a folder's door, so the tests that start several apps set it).
+  const listen = options.listen !== false && options.host !== true
+  const leaveOut = new Set<string>()
+  let extensionsReadOnly = false
+  // In the frame host the infrastructure rows are the host's own (its server, its web-server port, its router, the app instance, the door): the app
+  // contributes only the plugins that are its own.
+  if (!listen || options.host === true) leaveOut.add('acryl-node-server').add('acryl-door')
+  if (options.host === true)
+    for (const row of [
+      'instance',
+      'acryl-router',
+      'acryl-web-server',
+      'acryl-page',
+      'manifest',
+      'save',
+    ])
+      leaveOut.add(row)
+  // The Assistant (production, ACRYL_ASSISTANT=on): the agent panel docked for the app's visitors. Its agent keeps only the page tools and the door only the page,
+  // so it uses the app for a visitor (opens pages, filters, fills in forms) and cannot change the app, its code or its secrets. Not in the frame host.
+  const assistant =
+    process.env.NODE_ENV === 'production' &&
+    process.env.ACRYL_ASSISTANT === 'on' &&
+    process.env.ACRYL_DOOR !== 'off' &&
+    listen
+  if (!assistant && (process.env.NODE_ENV === 'production' || process.env.ACRYL_DOOR === 'off'))
+    leaveOut.add('acryl-door')
+  // Production: the rows that give a visitor power over the running app or the owner's model key are left out too. The agent (`POST /ask` spends the model key and runs tools),
+  // the builder and the extensions (live plugin install runs code in this process, and `POST /extensions/approve` decides it) are development tools. `ACRYL_PRODUCTION_KEEP`
+  // names the ones to keep (`agent,builder,extensions`); each one kept is announced at start, because none of them is behind a login.
+  if (process.env.NODE_ENV === 'production') {
+    const keep = new Set(
+      (process.env.ACRYL_PRODUCTION_KEEP ?? '')
+        .split(',')
+        .map((name) => name.trim())
+        .filter((name) => name !== ''),
+    )
+    for (const name of keep)
+      if (!(name in DEVELOPMENT_ROWS))
+        console.warn(
+          `WARNING: ACRYL_PRODUCTION_KEEP names "${name}", which is not one of ${Object.keys(DEVELOPMENT_ROWS).join(', ')}`,
+        )
+    for (const [row, danger] of Object.entries(DEVELOPMENT_ROWS)) {
+      if (keep.has(row))
+        console.warn(
+          `WARNING: the "${row}" row runs in production because ACRYL_PRODUCTION_KEEP names it: ${danger}. Nothing here is behind a login; put the app behind your own.`,
+        )
+      else if (row === 'extensions') extensionsReadOnly = true
+      else if (!(assistant && row === 'agent')) leaveOut.add(row)
+    }
+  }
+  const manifest = {
+    ...read,
+    plugins: read.plugins.map((row) => (leaveOut.has(row.use) ? { ...row, disabled: true } : row)),
+  }
+  const extensionsDir = join(chosen.root, 'plugins')
+  // One release of grace: an app made before 0.7.8 kept what the agent wrote in `extensions/`. It is still installed, with a warning.
+  const legacyDir = join(chosen.root, 'extensions')
+  const legacy = existsSync(legacyDir)
+  if (legacy)
+    console.warn(
+      'warning: extensions/ is the old folder for plugins the agent writes; move them to plugins/ ("git mv extensions/<name> plugins/<name>"). extensions/ is read for this release only.',
+    )
+  // The Assistant's model is told it helps a visitor through the page alone, and each answer is capped, unless the app's model configuration says otherwise.
+  const modelConfig =
+    options.model && assistant
+      ? {
+          ...options.model,
+          system: options.model.system ?? ASSISTANT_PROMPT,
+          maxTokens: options.model.maxTokens ?? ASSISTANT_MAX_TOKENS,
+        }
+      : options.model
+  if (assistant && !options.model)
+    console.warn(
+      `WARNING: the Assistant has no model, so it answers every visitor "${ASSISTANT_NO_MODEL}" Set the app's model (ACRYLBLENDS_MODEL_URL and ACRYLBLENDS_MODEL, or model.json in the app's home).`,
+    )
+  // The rows that name one of the app's own plugin folders (a feature: plugins/<name>/ and its row) rather than a registry import. Each one that runs
+  // is imported here; all of them, off or on, belong to their row, so the extensions row never starts them a second time.
+  const ownRows = [
+    ...new Set(read.plugins.map((row) => row.use).filter((use) => !Object.hasOwn(registry, use))),
+  ]
+  const ownPlugins = await loadAppPlugins(
+    PLUGINS_DIR,
+    ownRows.filter((use) => manifest.plugins.some((row) => row.use === use && !row.disabled)),
+  )
+  const fibers: Fiber[] = [
+    // The `model` row mounts the scripted model, or the real one when a model is configured.
+    ...(await compose(
+      ctx,
+      manifest,
+      { ...registry, ...ownPlugins, ...(modelConfig ? { model: openai } : {}) },
+      {
+        ...(modelConfig ? { model: { ...modelConfig } } : {}),
+        // Runtime values the manifest cannot hold: the manifest's own digest (every task records it), and who may install.
+        tasks: { manifest: `sha256:${manifest.digest}` },
+        // The `approval` parameter in blend.yaml (the extensions row) turns this source into one that asks.
+        extensions: {
+          ...(extensionsReadOnly ? { readOnly: true } : {}),
+          sources: [
+            { dir: extensionsDir, trust: 'install' },
+            ...(legacy ? [{ dir: legacyDir, trust: 'install' as const }] : []),
+          ],
+          rows: ownRows,
+          // Messages name a route as the plugin wrote it, not under the frame's canvas prefix.
+          ...(options.host === true ? { routePrefix: FRAME_MOUNT_PREFIX } : {}),
+        },
+        builder: { dir: extensionsDir },
+        'plugin-share': { dir: extensionsDir },
+        ...(assistant
+          ? {
+              // Every answer comes right after a look, so it says what the visitor's page shows now.
+              agent: { tools: ASSISTANT_TOOLS, steps: ASSISTANT_STEPS, answerAfter: 'door_look' },
+              'acryl-door': { pageOnly: true },
+              'agent-panel': { assistant: true },
+              // The visitor reaches the agent through the panel only: no /ask, /tasks or /extensions routes.
+              routes: { agentRoutes: false },
+            }
+          : {}),
+        // The rows that serve routes of their own mount them under the app's prefix, as makeApp does. On the app's own server that prefix is the root (the
+        // row's default); the frame host serves the app at FRAME_MOUNT_PREFIX, and its own `/api` routes would answer for a row left at the root. The
+        // app's own routes row takes the same prefix for its mount and for the absolute URLs its pages write, so the page and its assets answer at `/app`.
+        ...(options.host === true
+          ? {
+              'agent-panel': { mount: FRAME_MOUNT_PREFIX },
+              'driver-pty': { mount: FRAME_MOUNT_PREFIX },
+              feedback: { mount: FRAME_MOUNT_PREFIX },
+              routes: { prefix: FRAME_MOUNT_PREFIX, ...(assistant ? { agentRoutes: false } : {}) },
+            }
+          : {}),
+        // The frame host runs the server itself and its app instance carries no port; only the app's own server configures one.
+        ...(options.host === true
+          ? {}
+          : {
+              server: {
+                port: chosen.port.start,
+                scan: chosen.port.scan ? 20 : 0,
+                hostname: chosen.host,
+              },
+            }),
+      },
+    )),
+  ]
+  // Without a model the scripted one would echo the visitor's words back: it says in one sentence that the Assistant is not set up.
+  if (assistant && !options.model)
+    scripted(ctx.get('model') as Parameters<typeof scripted>[0])?.teach(() => ({
+      text: ASSISTANT_NO_MODEL,
+    }))
+  return fibers
+}
+
+/**
+ * The app: `instance` first (where it lives, chosen at run time), then the manifest's rows in order. The app's `plugins/`
+ * folder is trusted to install at start, and is where the builder writes.
+ */
+export async function createApp(
+  chosen: AppInstance,
+  options: {
+    values?: Readonly<Record<string, ParameterValue>>
+    /** A real model (any OpenAI-compatible API) in place of the offline scripted one. */
+    model?: OpenAIConfig
+    /** Start the HTTP server (default). Tests pass `false` and call `app.root.router.request(path)`: it needs no port, so it also runs where a sandbox forbids listening. */
+    listen?: boolean
+  } = {},
+): Promise<App> {
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [first, ...(await composeInto(root, chosen, options))]
+  return {
+    root,
+    url: options.listen === false ? '' : root.nodeServer.url,
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}

package/legacy/agent/ecbc84f1c1e5/src/routes.ts

@@ -0,0 +1,145 @@
+import type { Context } from '@deepseek-ai/cordis'
+import { Acryl } from '../plugins/acryl-router/src/index.ts'
+import { bodyLimit } from '../plugins/acryl-router/src/middleware/index.ts'
+import type {} from '../plugins/agent/index.ts'
+import type {} from '../plugins/extensions/index.ts'
+import type {} from '../plugins/tasks/index.ts'
+
+export const APP_NAME = '__APP_NAME__'
+
+/** The only place the app's mount prefix is named: the root on its own server (`npm start`), `/app` when the ACRYL frame hosts it (`npm run dev`). */
+export const FRAME_MOUNT_PREFIX = '/app'
+
+/** The door's page script (`.acryl/bin/acryl look` and `act`), in development only: `src/app.ts` leaves the door out in production and with ACRYL_DOOR=off. */
+const DOOR_TAG =
+  process.env.NODE_ENV !== 'production' && process.env.ACRYL_DOOR !== 'off'
+    ? '<script type="module" src="/api/acryl-door/page.js"></script>'
+    : ''
+
+/**
+ * The app's own routes on the router. Always: the page and `GET /health`. While the agent, the extensions and the task recorder run: `POST /ask` for the agent; `GET /extensions`
+ * (and `POST /extensions/approve` and `/deny`) and `GET /tasks` to observe and steer what it did (every run is a durable task owning one task per tool call); `POST /tasks/cancel`.
+ * What changes is also streamed: `GET /api/state/tasks/events` and `GET /api/state/extensions/events` (a page follows them with `watch` of `/api/state/client.js`, over one WebSocket). In production `src/app.ts` leaves the agent and builder rows out
+ * and starts the extensions read-only (unless `ACRYL_PRODUCTION_KEEP` names them), and then those routes are not mounted at all. The mounts are removed when the plugin is disposed.
+ */
+/**
+ * The app's look: the person's choice from /settings (kept in this browser), as `GET /appearance.js`. One script tag in a page's head (`<script src="/appearance.js"></script>`) applies it
+ * before the page paints, again whenever another window of the app changes it (the `storage` event), and defines the colours as custom properties for the page to use:
+ * `--bg`, `--fg`, `--muted`, `--surface`, `--border`, `--accent` (`html[data-theme=dark|light]` is set when the person chose one, and the system's choice decides otherwise). A page the agent builds
+ * carries the tag and colours itself with `var(--bg)` and the rest, and so follows Dark and Light.
+ */
+const APPEARANCE_JS = `(function () {
+  var root = document.documentElement
+  function apply() {
+    var saved
+    try { saved = localStorage.getItem('theme') } catch (e) { /* storage blocked: follow the system */ }
+    if (saved === 'dark' || saved === 'light') root.dataset.theme = saved
+    else delete root.dataset.theme
+  }
+  apply()
+  addEventListener('storage', function (event) { if (event.key === null || event.key === 'theme') apply() })
+  var light = '--bg:#ffffff;--fg:#111827;--muted:#6b7280;--surface:#f3f4f6;--border:#d1d5db;--accent:#2563eb'
+  var dark = '--bg:#111827;--fg:#f9fafb;--muted:#9ca3af;--surface:#1f2937;--border:#374151;--accent:#60a5fa'
+  var style = document.createElement('style')
+  style.id = 'appearance'
+  style.textContent = ':root{color-scheme:light dark;' + light + '}'
+    + '@media (prefers-color-scheme:dark){html:not([data-theme]){' + dark + '}}'
+    + 'html[data-theme=dark]{color-scheme:dark;' + dark + '}'
+    + 'html[data-theme=light]{color-scheme:light;' + light + '}'
+    + 'html{background:var(--bg);color:var(--fg)}'
+  ;(document.head || root).appendChild(style)
+})()
+`
+/** The home and settings pages' own layout; their colours come from /appearance.js. */
+const APPEARANCE_STYLE =
+  '<style>body{font:16px system-ui,sans-serif;margin:2rem auto;max-width:42rem;padding:0 1rem}a{color:inherit}</style>'
+const appearanceScript = (prefix: string) => `<script src="${prefix}/appearance.js"></script>`
+
+/** `/settings`: the one setting the template has, the appearance. The desktop app's Settings menu item opens this page. */
+const settingsPage = (prefix: string) =>
+  `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Settings - ${APP_NAME}</title>${APPEARANCE_STYLE}${appearanceScript(prefix)}</head><body><h1>Settings</h1><p><label for="theme">Appearance</label> <select id="theme" name="theme"><option value="system">Match the system</option><option value="light">Light</option><option value="dark">Dark</option></select></p><p id="saved" role="status"></p><p><a href="${prefix}/">Back to ${APP_NAME}</a></p><script>(function(){var select=document.getElementById('theme'),saved=document.getElementById('saved');try{select.value=localStorage.getItem('theme')||'system'}catch(e){}select.addEventListener('change',function(){var value=select.value;try{if(value==='system'){localStorage.removeItem('theme');delete document.documentElement.dataset.theme}else{localStorage.setItem('theme',value);document.documentElement.dataset.theme=value}saved.textContent='Saved: '+select.options[select.selectedIndex].text}catch(e){saved.textContent='This browser would not keep the setting.'}})})()</script></body></html>`
+
+/**
+ * The app's own pages and routes, mountable at any prefix: the standalone server mounts it at the root, the frame row at {@link FRAME_MOUNT_PREFIX}.
+ * Every absolute URL a page writes is derived from the prefix it is mounted at.
+ */
+export function makeApp(prefix = ''): Acryl {
+  const limit = bodyLimit({ maxSize: 64 * 1024 })
+  return (
+    new Acryl()
+      .use(limit)
+      // A browser gets a page (the door's and the agent panel's script tags are added where they are mounted); everything else gets the JSON.
+      .get('/', (c) =>
+        (c.req.header('accept') ?? '').includes('text/html')
+          ? c.html(
+              `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${APP_NAME}</title>${APPEARANCE_STYLE}${appearanceScript(prefix)}</head><body><h1>${APP_NAME}</h1><p>This app runs an agent unless it is switched off (production switches it off, see ACRYL_PRODUCTION_KEEP in AGENTS.md). In ACRYL, ask it for a change in the chat beside the app (or with <code>POST /ask</code>); published with the assistant on, it helps visitors use the app without changing it.</p>${DOOR_TAG}</body></html>`,
+            )
+          : c.json({ app: APP_NAME, ok: true }),
+      )
+      .get('/health', (c) => c.json({ ok: true }))
+      .get('/settings', (c) => c.html(settingsPage(prefix)))
+      .get('/appearance.js', (c) =>
+        c.body(APPEARANCE_JS, 200, {
+          'content-type': 'text/javascript; charset=utf-8',
+          'cache-control': 'no-cache',
+        }),
+      )
+  )
+}
+
+/** The app's own routes: an `App` mounted on the router at `options.prefix` (empty or absent: the root). */
+export const routes = {
+  name: 'routes',
+  inject: ['router'],
+  apply(ctx: Context, options: { readonly prefix?: string; readonly agentRoutes?: boolean } = {}) {
+    const prefix = options.prefix ?? ''
+    // A body here is a name, an id or a question; anything bigger is refused before it is read.
+    const json = async (c: {
+      req: { json(): Promise<unknown> }
+    }): Promise<Record<string, unknown>> => {
+      const body = await c.req.json().catch(() => undefined)
+      return typeof body === 'object' && body !== null ? (body as Record<string, unknown>) : {}
+    }
+    const limit = bodyLimit({ maxSize: 64 * 1024 })
+    // The app's own page and routes at the one prefix; the agent routes below mount at the same prefix.
+    ctx.router.route(prefix === '' ? '/' : prefix, makeApp(prefix))
+    // The routes that give a visitor the agent: mounted only while the agent, the extensions and the tasks run (see the header).
+    // `agentRoutes: false` (the production Assistant) keeps them unmounted although the agent runs.
+    if (options.agentRoutes === false) return
+    ctx.inject(['agent', 'extensions', 'tasks'], (inner) => {
+      const app = new Acryl().use(limit).get('/extensions', (c) =>
+        c.json({
+          installed: inner.extensions.list(),
+          notInstalled: inner.extensions.pending(),
+          waitingForApproval: inner.extensions.approvals(),
+        }),
+      )
+      // The owner's decision on an install that is waiting (the `approval` parameter in blend.yaml).
+      for (const [path, decide] of [
+        ['/extensions/approve', (name: string) => inner.extensions.approve(name)],
+        ['/extensions/deny', (name: string) => inner.extensions.deny(name)],
+      ] as const) {
+        app.post(path, async (c) => {
+          const { name } = await json(c)
+          if (typeof name !== 'string') return c.json({ error: 'name must be a string' }, 400)
+          return c.json(await decide(name))
+        })
+      }
+      app
+        .get('/tasks', (c) => c.json(inner.tasks.list().slice(0, 100)))
+        .post('/tasks/cancel', async (c) => {
+          const { id } = await json(c)
+          if (typeof id !== 'string' || !inner.tasks.get(id))
+            return c.json({ error: 'no such task' }, 404)
+          return c.json({ cancelled: inner.tasks.cancel(id) })
+        })
+        .post('/ask', async (c) => {
+          const { question } = await json(c)
+          if (typeof question !== 'string')
+            return c.json({ error: 'question must be a string' }, 400)
+          return c.json(await inner.agent.run(question))
+        })
+      inner.router.route(prefix === '' ? '/' : prefix, app)
+    })
+  },
+}

package/legacy/blank/2447ac6d5d24/src/app.ts

@@ -0,0 +1,61 @@
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import * as nodeServer from './plugins/acryl-node-server/src/index.ts'
+import * as router from './plugins/acryl-router/src/index.ts'
+import { type AppInstance, instance } from './plugins/instance/index.ts'
+import {
+  blueprintsIn,
+  compose,
+  loadManifest,
+  type ParameterValue,
+} from './plugins/manifest/index.ts'
+import { routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = { 'acryl-router': router, 'acryl-node-server': nodeServer, routes }
+
+/** The manifest next to this app's source. */
+export const MANIFEST = join(fileURLToPath(new URL('..', import.meta.url)), 'blend.yaml')
+
+/**
+ * The app's manifest, resolved. A Blend finds its Blueprint in `blueprints/<id>.yaml`; an app that is itself a Blueprint never looks.
+ * `createApp` and the tests read it the same way.
+ */
+export function readManifest(values?: Readonly<Record<string, ParameterValue>>) {
+  return loadManifest(MANIFEST, {
+    known: Object.keys(registry),
+    getBlueprint: blueprintsIn(join(fileURLToPath(new URL('..', import.meta.url)), 'blueprints')),
+    ...(values ? { values } : {}),
+  })
+}
+
+export interface App {
+  readonly root: Context
+  readonly url: string
+  stop(): Promise<void>
+}
+
+/** The app: `instance` first (where it lives, chosen at run time), then the manifest's rows in order. */
+export async function createApp(
+  chosen: AppInstance,
+  options: { values?: Readonly<Record<string, ParameterValue>> } = {},
+): Promise<App> {
+  const manifest = readManifest(options.values)
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [
+    first,
+    ...(await compose(root, manifest, registry, {
+      server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0 },
+    })),
+  ]
+  return {
+    root,
+    url: root.nodeServer.url,
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}

package/legacy/blank/387f7e25aaeb/src/app.ts

@@ -0,0 +1,81 @@
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import * as nodeServer from '../plugins/acryl-node-server/src/index.ts'
+import * as router from '../plugins/acryl-router/src/index.ts'
+import { type AppInstance, instance } from '../plugins/instance/index.ts'
+import {
+  blueprintsIn,
+  compose,
+  loadManifest,
+  type ParameterValue,
+} from '../plugins/manifest/index.ts'
+import { routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = { 'acryl-router': router, 'acryl-node-server': nodeServer, routes }
+
+/** The manifest next to this app's source. */
+export const MANIFEST = join(fileURLToPath(new URL('..', import.meta.url)), 'blend.yaml')
+
+/**
+ * The app's manifest, resolved. A Blend finds its Blueprint in `blueprints/<id>.yaml`; an app that is itself a Blueprint never looks.
+ * `createApp` and the tests read it the same way.
+ */
+export function readManifest(values?: Readonly<Record<string, ParameterValue>>) {
+  return loadManifest(MANIFEST, {
+    known: Object.keys(registry),
+    getBlueprint: blueprintsIn(join(fileURLToPath(new URL('..', import.meta.url)), 'blueprints')),
+    ...(values ? { values } : {}),
+  })
+}
+
+/** The manifest without its server row: the app is then reached in process, through `root.router.request`. */
+function withoutServer<M extends { plugins: readonly { use: string }[] }>(manifest: M): M {
+  return {
+    ...manifest,
+    plugins: manifest.plugins.map((row) =>
+      row.use === 'acryl-node-server' ? { ...row, disabled: true } : row,
+    ),
+  }
+}
+
+export interface App {
+  readonly root: Context
+  /** The address the server listens on; empty when the app was made with `listen: false`. */
+  readonly url: string
+  stop(): Promise<void>
+}
+
+/** The app: `instance` first (where it lives, chosen at run time), then the manifest's rows in order. */
+export async function createApp(
+  chosen: AppInstance,
+  options: {
+    values?: Readonly<Record<string, ParameterValue>>
+    /** Start the HTTP server (default). Tests pass `false` and call `app.root.router.request(path)`: it needs no port, so it also runs where a sandbox forbids listening. */
+    listen?: boolean
+  } = {},
+): Promise<App> {
+  const manifest = readManifest(options.values)
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [
+    first,
+    ...(await compose(
+      root,
+      options.listen === false ? withoutServer(manifest) : manifest,
+      registry,
+      {
+        server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0 },
+      },
+    )),
+  ]
+  return {
+    root,
+    url: options.listen === false ? '' : root.nodeServer.url,
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}

package/legacy/blank/5b9f10e1ba5e/src/app.ts

@@ -0,0 +1,61 @@
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import * as nodeServer from './plugins/acryl-node-server/src/index.ts'
+import * as router from './plugins/acryl-router/src/index.ts'
+import { type AppInstance, instance } from './plugins/instance/index.ts'
+import {
+  blueprintsIn,
+  compose,
+  loadManifest,
+  type ParameterValue,
+} from './plugins/manifest/index.ts'
+import { routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = { 'acryl-router': router, 'acryl-node-server': nodeServer, routes }
+
+/** The manifest next to this app's source. */
+export const MANIFEST = join(fileURLToPath(new URL('..', import.meta.url)), 'blend.yaml')
+
+/**
+ * The app's manifest, resolved. A Blend finds its Blueprint in `blueprints/<id>.yaml`; an app that is itself a Blueprint never looks.
+ * `createApp` and the tests read it the same way.
+ */
+export function readManifest(values?: Readonly<Record<string, ParameterValue>>) {
+  return loadManifest(MANIFEST, {
+    known: Object.keys(registry),
+    getBlueprint: blueprintsIn(join(fileURLToPath(new URL('..', import.meta.url)), 'blueprints')),
+    ...(values ? { values } : {}),
+  })
+}
+
+export interface App {
+  readonly root: Context
+  readonly url: string
+  stop(): Promise<void>
+}
+
+/** The app: `instance` first (where it lives, chosen at run time), then the manifest's rows in order. */
+export async function createApp(
+  chosen: AppInstance,
+  options: { values?: Readonly<Record<string, ParameterValue>> } = {},
+): Promise<App> {
+  const manifest = readManifest(options.values)
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [
+    first,
+    ...(await compose(root, manifest, registry, {
+      server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0 },
+    })),
+  ]
+  return {
+    root,
+    url: root.nodeServer.url,
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}