acrylblends 1.0.4 → 1.0.6

package/plugins/extensions/stage.ts

@@ -5,32 +5,60 @@
  * code; a copy at a new path has fresh URLs for the entry and everything it imports, so it is evaluated anew. The author's source folder
  * is never modified. The hash makes an unchanged source recognisable; the stamp makes "newest" well defined.
  */
-import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from 'node:fs'
+import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from 'node:fs'
 import { basename, join } from 'node:path'
 import { digestFolder, FOLDER_DIGEST_SKIPPED } from '@webboxes/blends-core'
 
 /** A short content digest of a folder, so an unchanged source keeps its version. */
 export const hashFolder = (dir: string, length = 12): string => digestFolder(dir, length)
 
-/** Copy `source` into a new version folder under `stageRoot/<name>/` and return its path and version. */
+/**
+ * Whether `node --watch` runs this process. It watches every module the process has imported, and keeps watching the paths of the runs before; a staged copy that is deleted
+ * while it is watched restarts the app, and the restart stages and prunes again: a loop. So under the watcher a staged copy is never deleted (a later start without it prunes).
+ */
+export const watched = (): boolean => process.env.WATCH_REPORT_DEPENDENCIES === '1'
+
+/** Delete a staged folder, unless the watcher would take the deletion for a change of the app. */
+export function discard(dir: string): void {
+  if (!watched()) rmSync(dir, { recursive: true, force: true })
+}
+
+/** The newest complete staged copy of `version` (copies are finished under a temporary name and renamed, so a folder with the final name is whole). */
+function staged(stageRoot: string, name: string, version: string): string | undefined {
+  const folder = join(stageRoot, name)
+  if (!existsSync(folder)) return undefined
+  const found = readdirSync(folder)
+    .filter((entry) => !entry.startsWith('.') && entry.endsWith(`-${version}`))
+    .sort()
+    .pop()
+  return found === undefined ? undefined : join(folder, found)
+}
+
+/** Copy `source` into a version folder under `stageRoot/<name>/` and return its path and version. An unchanged source reuses its copy: a restart stages nothing new. */
 export function stage(
   source: string,
   stageRoot: string,
   name: string,
 ): { dir: string; version: string } {
   const version = hashFolder(source)
+  const existing = staged(stageRoot, name, version)
+  if (existing !== undefined) return { dir: existing, version }
   const stamp = String(Date.now()).padStart(15, '0')
   const dir = join(stageRoot, name, `${stamp}-${version}`)
-  mkdirSync(dir, { recursive: true })
-  cpSync(source, dir, {
+  const partial = join(stageRoot, name, `.${stamp}-${version}.partial`)
+  rmSync(partial, { recursive: true, force: true })
+  mkdirSync(partial, { recursive: true })
+  cpSync(source, partial, {
     recursive: true,
     filter: (path) => !FOLDER_DIGEST_SKIPPED.has(basename(path)),
   })
+  renameSync(partial, dir)
   return { dir, version }
 }
 
-/** Delete staged versions of `name` except the ones to keep (best effort). Modules already loaded stay in memory until the app restarts. */
+/** Delete staged versions of `name` except the ones to keep (best effort; none under the watcher, see `watched`). Modules already loaded stay in memory until the app restarts. */
 export function prune(stageRoot: string, name: string, keep: readonly string[]): void {
+  if (watched()) return
   const folder = join(stageRoot, name)
   if (!existsSync(folder)) return
   if (keep.length === 0) {

package/plugins/openai/index.ts

@@ -102,7 +102,7 @@ export async function complete(
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: { type: 'object', additionalProperties: true },
+          parameters: tool.parameters ?? { type: 'object', additionalProperties: true },
         },
       })),
     }),

package/templates/agent/AGENTS.md

@@ -5,4 +5,8 @@ Besides `src/routes.ts`, the app runs an agent (`POST /ask`) that can write plug
 rollback; `GET /extensions` and `GET /tasks` show what it did. A plugin there is a folder with an `index.ts` exporting `name`, `inject`, `apply(ctx)`
 and an optional `check(ctx)` that receives the plugin's own context (so `ctx.router` reads as in `apply`). It may import `acryl-router`.
 
+**Write an extension, not a row.** A feature you build while the app runs is a folder `plugins/<name>/` installed with `.acryl/bin/acryl plugin add plugins/<name>` (the `extensions` plugin loads it again at every start). Add a row to `blend.yaml` and an entry to the `registry` of `src/app.ts` only when the person asks for a plugin that is part of the app itself. Both kinds may import the framework by name (`acrylblends`, `acrylblends/body-limit`, `acryl-router`); a row's relative imports of its sibling plugins also work.
+
+**Drive the app you build.** `.acryl/bin/acryl look` reads the open page as text with refs, and `acryl act click|type|press|scroll|wait --ref <ref>` presses its buttons, opens its sidebars and fills its forms (look again before each act: the refs change). `act navigate --path /settings` goes to another page of the app; a path the app does not serve answers `404 at /nope` and the window shows a 404 page, so navigate on from there. In the desktop app (`npm run desktop`) the app's windows and menu are verbs too: `acryl window list`, `acryl window open --path /settings`, `acryl look --window <id>` (and `act ... --window <id>`) to drive that window's page, `acryl window resize|focus|close --id <id>`, `acryl menu list` and `acryl menu click --path "File>New Note"`. Closing the last window and Quit end the desktop app, so they need `--force`: do not use it unless the person asks. When a person asks for settings, build them as a page at `/settings`, so `acryl window open --path /settings` opens them in every app. Without a desktop app these answer "no desktop window is attached; run npm run desktop".
+
 **Production.** The agent, the builder and the extensions are development tools: `POST /ask` spends the model key and runs tools, a plugin installed live runs in this process, and none of it is behind a login. With `NODE_ENV=production` `src/app.ts` leaves those three rows out, so `/ask`, `/extensions*` and `/tasks*` are not mounted; the page and `GET /health` stay. `ACRYL_PRODUCTION_KEEP=agent,builder,extensions` keeps the named rows, and each one kept prints a `WARNING` line at start.

package/templates/agent/blend.yaml

@@ -14,7 +14,7 @@ spec:
     # The address the server listens on.
     hostname: { type: string, default: 127.0.0.1 }
     # Steps an agent run may take.
-    steps: { type: number, default: 6 }
+    steps: { type: number, default: 12 }
     # Where task records are kept: jsonl (a text file) or sqlite.
     taskStore: { type: string, default: jsonl }
     # When true, a plugin the agent installs waits for POST /extensions/approve.
@@ -48,6 +48,9 @@ spec:
       name: builder
     - id: save
       name: save
+    # The panel: a chat button on every page in development (the app's own agent, or Codex, Claude or pi started in this folder). It starts nothing in production.
+    - id: agent-panel
+      name: agent-panel
     - id: routes
       name: routes
     - id: server

package/templates/agent/src/app.ts

@@ -7,6 +7,7 @@ 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, 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'
@@ -37,6 +38,7 @@ export const registry = {
   sandbox: sandboxPlugin,
   routes,
   'acryl-node-server': nodeServer,
+  'agent-panel': panel,
   'acryl-door': door,
 }
 

package/templates/agent/src/routes.ts

@@ -37,7 +37,7 @@ export const routes = {
       .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></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). Ask it for a feature (<code>POST /ask</code>), or add the chat panel with <code>npx acrylblends add agent-panel</code>.</p>${DOOR_TAG}</body></html>`,
+              `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${APP_NAME}</title></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). Ask it for a feature in the agent panel on this page (or with <code>POST /ask</code>).</p>${DOOR_TAG}</body></html>`,
             )
           : c.json({ app: APP_NAME, ok: true }),
       )

package/templates/agent/template.json

@@ -10,6 +10,7 @@
     "sandbox",
     "extensions",
     "builder",
+    "agent-panel",
     "manifest",
     "save",
     "acryl-door"

package/templates/agent/test/builder.test.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict'
+import { randomBytes } from 'node:crypto'
 import { mkdirSync } from 'node:fs'
 import { mkdtemp, rm } from 'node:fs/promises'
 import { join } from 'node:path'
@@ -7,6 +8,9 @@ import { fileURLToPath } from 'node:url'
 import { pinnedInstance, withPort } from '../plugins/instance/index.ts'
 import { createApp } from '../src/app.ts'
 
+/** The plugin this test has the agent build: a name of its own, so a route the app has (a person's /hello) can never shadow it and fail the template's tests. */
+const NAME = `builder-probe-${randomBytes(3).toString('hex')}`
+
 /** Throwaway homes live inside the project (`.acrylblends/` is ignored by git): a sandboxed agent may not write to the system temp folder. */
 const scratch = join(fileURLToPath(new URL('..', import.meta.url)), '.acrylblends', 'test')
 mkdirSync(scratch, { recursive: true })
@@ -24,28 +28,28 @@ test('the agent builds, updates, protects and removes a plugin in the running ap
     })
     return ((await response.json()) as { output: string }).output
   }
-  const hello = async () => {
-    const response = await app.root.router.request(`/hello`)
+  const served = async () => {
+    const response = await app.root.router.request(`/${NAME}`)
     return response.status === 200
       ? ((await response.json()) as { text: string }).text
       : response.status
   }
   try {
-    assert.equal(await ask('create route hello /hello Hello'), 'hello: installed, active.')
-    assert.equal(await hello(), 'Hello')
-    assert.equal(await ask('update route hello /hello Bonjour'), 'hello: updated, active.')
-    assert.equal(await hello(), 'Bonjour')
-    assert.match(await ask('break plugin hello'), /Previous version restored: true/)
-    assert.equal(await hello(), 'Bonjour')
+    assert.equal(await ask(`create route ${NAME} /${NAME} Hello`), `${NAME}: installed, active.`)
+    assert.equal(await served(), 'Hello')
+    assert.equal(await ask(`update route ${NAME} /${NAME} Bonjour`), `${NAME}: updated, active.`)
+    assert.equal(await served(), 'Bonjour')
+    assert.match(await ask(`break plugin ${NAME}`), /Previous version restored: true/)
+    assert.equal(await served(), 'Bonjour')
 
     // The broken version stays on disk, so put the working one back before restarting.
-    await ask('update route hello /hello Bonjour')
+    await ask(`update route ${NAME} /${NAME} Bonjour`)
     await app.stop()
     app = await createApp(chosen, { listen: false })
-    assert.equal(await hello(), 'Bonjour')
+    assert.equal(await served(), 'Bonjour')
 
-    assert.equal(await ask('remove plugin hello'), 'hello: done.')
-    assert.equal(await hello(), 404)
+    assert.equal(await ask(`remove plugin ${NAME}`), `${NAME}: done.`)
+    assert.equal(await served(), 404)
 
     // Every run is a durable task that owns its tool calls, and the records survived the restart.
     const records = (await (await app.root.router.request(`/tasks`)).json()) as Array<{
@@ -81,22 +85,22 @@ test('with approval on, an install waits for the owner; approving it makes it li
     ).json()) as Record<string, unknown>
   try {
     assert.equal(
-      (await post('/ask', { question: 'create route hello /hello Hello' })).output,
-      "hello: waiting for the owner's approval.",
+      (await post('/ask', { question: `create route ${NAME} /${NAME} Hello` })).output,
+      `${NAME}: waiting for the owner's approval.`,
     )
-    assert.equal((await app.root.router.request(`/hello`)).status, 404)
+    assert.equal((await app.root.router.request(`/${NAME}`)).status, 404)
     const listed = (await (await app.root.router.request(`/extensions`)).json()) as {
       waitingForApproval: Array<{ name: string }>
     }
     assert.deepEqual(
       listed.waitingForApproval.map((request) => request.name),
-      ['hello'],
+      [NAME],
     )
     assert.equal(
-      ((await post('/extensions/approve', { name: 'hello' })) as { state?: string }).state,
+      ((await post('/extensions/approve', { name: NAME })) as { state?: string }).state,
       'active',
     )
-    assert.deepEqual(await (await app.root.router.request(`/hello`)).json(), { text: 'Hello' })
+    assert.deepEqual(await (await app.root.router.request(`/${NAME}`)).json(), { text: 'Hello' })
     const tasks = (await (await app.root.router.request(`/tasks`)).json()) as Array<{
       manifest?: string
     }>
@@ -168,12 +172,13 @@ test('what happens is streamed from the state cells: the run as a task, and the
     await app.root.router.request(`/ask`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ question: 'create route hello /hello Hello' }),
+      body: JSON.stringify({ question: `create route ${NAME} /${NAME} Hello` }),
     })
     const arrived = (stream: { text: string }, what: RegExp) => what.test(stream.text)
     for (
       let waited = 0;
-      waited < 3000 && !arrived(extensionsStream.seen, /"name":"hello"[^\n]*"state":"active"/);
+      waited < 3000 &&
+      !arrived(extensionsStream.seen, new RegExp(`"name":"${NAME}"[^\\n]*"state":"active"`));
       waited += 25
     ) {
       await new Promise((done) => setTimeout(done, 25))
@@ -189,7 +194,7 @@ test('what happens is streamed from the state cells: the run as a task, and the
     )
     assert.ok(arrived(tasksStream.seen, /"kind":"tool:install_plugin"/), 'the install is a task')
     assert.ok(
-      arrived(extensionsStream.seen, /"name":"hello"[^\n]*"state":"active"/),
+      arrived(extensionsStream.seen, new RegExp(`"name":"${NAME}"[^\\n]*"state":"active"`)),
       'the extension is reported',
     )
     // In process there is no socket to close: the readers are cancelled, which ends the streams and lets the pumps finish.

package/lib/helpers-CvTauQT5.js

@@ -1,5 +0,0 @@
-import "./factory.js";
-import "./ssg-BwjcA-Ge.js";
-import "./css.js";
-import "./connection-C7xgP1hP.js";
-export {};

package/lib/middleware-CPQ8himN.js

@@ -1,12 +0,0 @@
-import "./basic-auth.js";
-import "./combine.js";
-import "./context-storage.js";
-import "./ip-restriction.js";
-import "./jsx-renderer.js";
-import "./jwk-LkzeoaU8.js";
-import "./jwt-CskdhEW9.js";
-import "./method-not-allowed.js";
-import "./serve-static-Cp5adzGo.js";
-import "./timeout.js";
-import "./loopback-only.js";
-export {};

package/plugins/acryl-router/src/connection.d.ts

@@ -1,25 +0,0 @@
-/**
- * Transport facts: who is on the other end of the socket and which local port it reached. The caller of `router.fetch` supplies them
- * (an HTTP adapter passes the socket's peer address and real port); they travel in `c.env.connection`, beside the request and never in a header.
- */
-import type { Context } from './core/context.ts';
-import type { GetConnInfo } from './core/helper/conninfo/types.ts';
-/** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */
-export interface ConnectionInfo {
-    /** The peer address of the socket, when the request came over one (for example `127.0.0.1`). */
-    readonly remoteAddress?: string | undefined;
-    /** The local port the socket is connected to, the real one a `Host` header should be checked against. */
-    readonly localPort?: number | undefined;
-}
-/** What the router puts in `c.env`. */
-export interface RouterBindings {
-    readonly connection: ConnectionInfo;
-}
-/** The `Env` of an `Acryl` that wants `c.env.connection` typed: `new Acryl<RouterEnv>()`. */
-export interface RouterEnv {
-    Bindings: RouterBindings;
-}
-/** The transport facts of this request; empty for an in-process call or an `Acryl` run outside the router. */
-export declare function connectionOf(c: Context): ConnectionInfo;
-/** The peer in the core's conninfo shape, for middleware written against it (for example `ipRestriction`). */
-export declare const getConnInfo: GetConnInfo;

package/plugins/acryl-router/src/core/app-base.d.ts

@@ -1,215 +0,0 @@
-/**
- * @module
- * This module is the base module for the Acryl object.
- */
-import { Context } from './context.ts';
-import type { ExecutionContext } from './context.ts';
-import type { Router } from './router.ts';
-import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types.ts';
-type GetPath<E extends Env> = (request: Request, options?: {
-    env?: E['Bindings'];
-}) => string;
-export type AcrylOptions<E extends Env> = {
-    /**
-     * `router` option specifies which router to use.
-     *
-     *
-     * @example
-     * ```ts
-     * const app = new Acryl({ router: new RegExpRouter() })
-     * ```
-     */
-    router?: Router<[H, RouterRoute]>;
-} & ({
-    /**
-     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
-     *
-     *
-     * @default true
-     */
-    strict?: true;
-    /**
-     * `getPath` can handle the host header value.
-     *
-     *
-     * @example
-     * ```ts
-     * const app = new Acryl({
-     *  getPath: (req) =>
-     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
-     * })
-     *
-     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
-     *
-     * // A following request will match the route:
-     * // new Request('http://www1.example.com/hello', {
-     * //  headers: { host: 'www1.example.com' },
-     * // })
-     * ```
-     */
-    getPath?: GetPath<E>;
-} | {
-    /**
-     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
-     * When `strict` is `false`, `getPath` is not used.
-     *
-     *
-     * @default true
-     */
-    strict: false;
-    getPath?: never;
-});
-type MountOptionHandler = (c: Context) => unknown;
-type MountReplaceRequest = (originalRequest: Request) => Request;
-type MountOptions = MountOptionHandler | {
-    optionHandler?: MountOptionHandler;
-    replaceRequest?: MountReplaceRequest | false;
-};
-declare class Acryl<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
-    #private;
-    get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
-    post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
-    put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
-    delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
-    options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
-    patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
-    query: HandlerInterface<E, 'query', S, BasePath, CurrentPath>;
-    all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
-    on: OnHandlerInterface<E, S, BasePath>;
-    use: MiddlewareHandlerInterface<E, S, BasePath>;
-    router: Router<[H, RouterRoute]>;
-    readonly getPath: GetPath<E>;
-    private _basePath;
-    routes: RouterRoute[];
-    constructor(options?: AcrylOptions<E>);
-    private errorHandler;
-    /**
-     * `.route()` allows grouping other Acryl instance in routes.
-     *
-     *
-     * @param {string} path - base Path
-     * @param {Acryl} app - other Acryl instance
-     * @returns {Acryl} routed Acryl instance
-     *
-     * @example
-     * ```ts
-     * const app = new Acryl()
-     * const app2 = new Acryl()
-     *
-     * app2.get("/user", (c) => c.text("user"))
-     * app.route("/api", app2) // GET /api/user
-     * ```
-     */
-    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Acryl<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Acryl<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
-    /**
-     * `.basePath()` allows base paths to be specified.
-     *
-     *
-     * @param {string} path - base Path
-     * @returns {Acryl} changed Acryl instance
-     *
-     * @example
-     * ```ts
-     * const api = new Acryl().basePath('/api')
-     * ```
-     */
-    basePath<SubPath extends string>(path: SubPath): Acryl<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
-    /**
-     * `.onError()` handles an error and returns a customized Response.
-     *
-     *
-     * @param {ErrorHandler} handler - request Handler for error
-     * @returns {Acryl} changed Acryl instance
-     *
-     * @example
-     * ```ts
-     * app.onError((err, c) => {
-     *   console.error(`${err}`)
-     *   return c.text('Custom Error Message', 500)
-     * })
-     * ```
-     */
-    onError: (handler: ErrorHandler<E>) => Acryl<E, S, BasePath, CurrentPath>;
-    /**
-     * `.notFound()` allows you to customize a Not Found Response.
-     *
-     *
-     * @param {NotFoundHandler} handler - request handler for not-found
-     * @returns {Acryl} changed Acryl instance
-     *
-     * @example
-     * ```ts
-     * app.notFound((c) => {
-     *   return c.text('Custom 404 Message', 404)
-     * })
-     * ```
-     */
-    notFound: (handler: NotFoundHandler<E>) => Acryl<E, S, BasePath, CurrentPath>;
-    /**
-     * `.mount()` allows you to mount applications built with other frameworks into your Acryl application.
-     *
-     * @deprecated Use `mount()` from `acryl-router/mount` instead. `.mount()` will be removed in v5.
-     *
-     *
-     * @param {string} path - base Path
-     * @param {Function} applicationHandler - other Request Handler
-     * @param {MountOptions} [options] - options of `.mount()`
-     * @returns {Acryl} mounted Acryl instance
-     *
-     * @example
-     * ```ts
-     * import { Router as IttyRouter } from 'itty-router'
-     * import { Acryl } from 'acrylblends'
-     * // Create itty-router application
-     * const ittyRouter = IttyRouter()
-     * // GET /itty-router/hello
-     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-     *
-     * const app = new Acryl()
-     * app.mount('/itty-router', ittyRouter.handle)
-     * ```
-     *
-     * @example
-     * ```ts
-     * const app = new Acryl()
-     * // Send the request to another application without modification.
-     * app.mount('/app', anotherApp, {
-     *   replaceRequest: (req) => req,
-     * })
-     * ```
-     */
-    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Acryl<E, S, BasePath, CurrentPath>;
-    /**
-     * `.fetch()` will be entry point of your app.
-     *
-     *
-     * @param {Request} request - request Object of request
-     * @param {Env} env - env Object
-     * @param {ExecutionContext} executionCtx - context of execution
-     * @returns {Response | Promise<Response>} response of request
-     *
-     */
-    fetch: (request: Request, env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.request()` is a useful method for testing.
-     * You can pass a URL or pathname to send a GET request.
-     * app will return a Response object.
-     * ```ts
-     * test('GET /hello is ok', async () => {
-     *   const res = await app.request('/hello')
-     *   expect(res.status).toBe(200)
-     * })
-     * ```
-     */
-    request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.fire()` automatically adds a global fetch event listener.
-     * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-     * @deprecated
-     * ACRYL ships no service-worker adapter: mount the app with `ctx.router.route(path, app)` and serve it through an ACRYL adapter instead.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-     * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-     */
-    fire: () => void;
-}
-export { Acryl as AcrylBase };

package/plugins/acryl-router/src/core/app.d.ts

@@ -1,19 +0,0 @@
-import { AcrylBase } from './app-base.ts';
-import type { AcrylOptions } from './app-base.ts';
-import type { BlankEnv, BlankSchema, Env, Schema } from './types.ts';
-/**
- * The Acryl class extends the functionality of the AcrylBase class.
- * It sets up routing and allows for custom options to be passed.
- *
- * @template E - The environment type.
- * @template S - The schema type.
- * @template BasePath - The base path type.
- */
-export declare class Acryl<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends AcrylBase<E, S, BasePath> {
-    /**
-     * Creates an instance of the Acryl class.
-     *
-     * @param options - Optional configuration options for the Acryl instance.
-     */
-    constructor(options?: AcrylOptions<E>);
-}

package/plugins/acryl-router/src/core/client/client.d.ts

@@ -1,4 +0,0 @@
-import type { Acryl } from '../app.ts';
-import type { UnionToIntersection } from '../utils/types.ts';
-import type { Client, ClientRequestOptions } from './types.ts';
-export declare const hc: <T extends Acryl<any, any, any>, Prefix extends string = string>(baseUrl: Prefix, options?: ClientRequestOptions) => UnionToIntersection<Client<T, Prefix>>;

package/plugins/acryl-router/src/core/client/fetch-result-please.d.ts

@@ -1,35 +0,0 @@
-/**
- * @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Acryl's custom needs.
- *
- * @link https://www.npmjs.com/package/fetch-result-please
- */
-/**
- * Smartly parses and return the consumable result from a fetch `Response`.
- *
- * Throwing a structured error if the response is not `ok`. ({@link DetailedError})
- */
-export declare function fetchRP(fetchRes: Response | Promise<Response>): Promise<any>;
-export declare class DetailedError extends Error {
-    /**
-     * Additional `message` that will be logged AND returned to client
-     */
-    detail?: any;
-    /**
-     * Additional `code` that will be logged AND returned to client
-     */
-    code?: any;
-    /**
-     * Additional value that will be logged AND NOT returned to client
-     */
-    log?: any;
-    /**
-     * Optionally set the status code to return, in a web server context
-     */
-    statusCode?: any;
-    constructor(message: string, options?: {
-        detail?: any;
-        code?: any;
-        statusCode?: number;
-        log?: any;
-    });
-}

package/plugins/acryl-router/src/core/client/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module
- * The HTTP Client for Acryl.
- */
-export { hc } from './client.ts';
-export { parseResponse, DetailedError } from './utils.ts';
-export type { InferResponseType, InferRequestType, Fetch, ClientRequestOptions, ClientRequest, ClientResponse, ApplyGlobalResponse, PickResponseByStatusCode, } from './types.ts';