@chatluna/patchbay 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ChatLunaLab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,58 @@
-# Temporary Holding Version
+# patchbay
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Patches that run Koishi, Satori, the Satori adapters and a few Cordis plugins on **Cordis 4**, kept in one place and wired into yarn, pnpm or npm by one command.
+
+Each patch targets one exact upstream version listed in [`patchbay.json`](patchbay.json). Nothing is republished: your package manager installs the upstream tarball and applies the patch from this package.
+
+## Use
+
+```sh
+npm i -D @chatluna/patchbay      # or yarn add -D / pnpm add -D
+npx patchbay sync                # writes .patchbay/ and the package-manager config
+npm install                      # or yarn install / pnpm install
+```
+
+Commit `.patchbay/` together with the config `sync` writes. Run `patchbay sync` again after upgrading patchbay. It replaces every pin the previous version wrote.
+
+| Package manager | What `sync` writes                                                                             | When patches apply         |
+| --------------- | ---------------------------------------------------------------------------------------------- | -------------------------- |
+| Yarn 2+         | `resolutions` → `patch:<pkg>@npm:<version>#~/.patchbay/<pkg>@<version>.patch`                  | on install                 |
+| pnpm 10+        | `pnpm-workspace.yaml`: `overrides`, `patchedDependencies`, `allowUnusedPatches`                | on install                 |
+| npm             | `overrides`, direct dependencies pinned to the same spec, `postinstall: patchbay apply`        | after install, in place    |
+
+`sync` reads the package manager from `packageManager`, then the lockfile, then the one running it. Pass `--pm yarn|pnpm|npm` to choose it yourself. Yarn 1 has no patch support and is rejected.
+
+Every patched package is pinned to its patched version, along with these aliases:
+
+- `koishi` → `@koishijs/core`
+- `minato` → `@cordisjs/plugin-database`
+
+A plugin that later installs one of them gets the patched build.
+
+On npm, `patchbay apply` keeps a copy of the patch it applied in each package (`.patchbay.patch`). It skips packages that are already current and undoes an older patch before applying a newer one.
+
+### From code
+
+```ts
+import { apply, sync } from '@chatluna/patchbay'
+
+const pm = sync(projectDir) // 'yarn' | 'pnpm' | 'npm'
+// ...run the install...
+if (pm === 'npm') apply(projectDir)
+```
+
+## Maintain
+
+```sh
+yarn refresh edit <name>     # unpack upstream to .work/<pkg>/{a,b}, current patch applied to b
+# edit .work/<pkg>/b
+yarn refresh commit <name>   # diff a → b into patches/<pkg>@<version>.patch
+yarn verify                  # every patch applies to its upstream tarball
+yarn test                    # unit tests plus real yarn, pnpm and npm installs
+```
+
+To patch a new package or version, add its entry to `patchbay.json`, run `yarn refresh edit <name>`, make the change, then commit it.
+
+## License
+
+MIT

package/lib/apply.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Patch the matching packages in `<dir>/node_modules` in place, for npm, which has no patch protocol.
+ * Packages already carrying the current patch are skipped. Returns the patched paths.
+ */
+export declare function apply(dir: string): string[];

package/lib/apply.js

@@ -0,0 +1,59 @@
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { patchFileName } from './manifest.js';
+import { applyPatchText } from './patch.js';
+import { readPackageJson, readState, STATE_DIR } from './sync.js';
+/** Each patched package keeps the patch it carries, so a changed patch can be undone before the new one. */
+const MARKER = '.patchbay.patch';
+/** Real package directories under a `node_modules`, nested ones included; symlinks are not followed. */
+function* packages(modules) {
+    if (!existsSync(modules))
+        return;
+    for (const item of readdirSync(modules, { withFileTypes: true })) {
+        if (!item.isDirectory() || item.name.startsWith('.'))
+            continue;
+        const path = join(modules, item.name);
+        if (item.name.startsWith('@')) {
+            yield* packages(path);
+            continue;
+        }
+        if (existsSync(join(path, 'package.json')))
+            yield path;
+        yield* packages(join(path, 'node_modules'));
+    }
+}
+/**
+ * Patch the matching packages in `<dir>/node_modules` in place, for npm, which has no patch protocol.
+ * Packages already carrying the current patch are skipped. Returns the patched paths.
+ */
+export function apply(dir) {
+    const manifest = readState(dir);
+    if (!manifest)
+        throw new Error(`no ${STATE_DIR}/patchbay.json in ${dir}; run patchbay sync first`);
+    const entries = new Map(manifest.patches.map((entry) => [`${entry.name}@${entry.version}`, entry]));
+    const applied = [];
+    for (const path of packages(join(dir, 'node_modules'))) {
+        const { name, version } = readPackageJson(path);
+        const entry = entries.get(`${name}@${version}`);
+        if (!entry)
+            continue;
+        const text = readFileSync(join(dir, STATE_DIR, patchFileName(entry)), 'utf8');
+        const marker = join(path, MARKER);
+        const carried = existsSync(marker) ? readFileSync(marker, 'utf8') : undefined;
+        if (carried === text)
+            continue;
+        try {
+            if (carried !== undefined) {
+                applyPatchText(path, carried, { reverse: true });
+                rmSync(marker);
+            }
+            applyPatchText(path, text);
+        }
+        catch (error) {
+            throw new Error(`${name}@${version} at ${relative(dir, path)}: ${String(error)}`, { cause: error });
+        }
+        writeFileSync(marker, text);
+        applied.push(relative(dir, path));
+    }
+    return applied;
+}

package/lib/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/cli.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { apply } from './apply.js';
+import { loadManifest } from './manifest.js';
+import { isPackageManager, sync } from './sync.js';
+const usage = `usage: patchbay <command> [--dir <project>]
+
+  sync [--pm yarn|pnpm|npm]  copy the patches into .patchbay/ and wire them into the package manager
+  apply                      patch node_modules in place (npm postinstall; yarn and pnpm patch on install)
+  list                       print the patched packages`;
+const { positionals, values } = parseArgs({
+    allowPositionals: true,
+    options: { dir: { type: 'string', default: process.cwd() }, pm: { type: 'string' } }
+});
+const [command] = positionals;
+if (command === 'sync') {
+    if (values.pm !== undefined && !isPackageManager(values.pm))
+        throw new Error(`--pm must be yarn, pnpm or npm`);
+    const pm = sync(values.dir, values.pm === undefined ? {} : { pm: values.pm });
+    console.log(`patchbay: wired ${loadManifest().patches.length} patches into ${pm}; run \`${pm} install\``);
+}
+else if (command === 'apply') {
+    for (const path of apply(values.dir))
+        console.log(`patchbay: patched ${path}`);
+}
+else if (command === 'list') {
+    for (const entry of loadManifest().patches)
+        console.log(`${entry.name}@${entry.version}  ${entry.description}`);
+}
+else {
+    console.error(usage);
+    process.exitCode = 1;
+}

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { apply } from './apply.ts';
+export { loadManifest, patchFileName, patchPath, type Manifest, type PatchEntry } from './manifest.ts';
+export { applyPatchText } from './patch.ts';
+export { detect, isPackageManager, STATE_DIR, sync, type PackageManager, type SyncOptions } from './sync.ts';

package/lib/index.js

@@ -0,0 +1,4 @@
+export { apply } from './apply.js';
+export { loadManifest, patchFileName, patchPath } from './manifest.js';
+export { applyPatchText } from './patch.js';
+export { detect, isPackageManager, STATE_DIR, sync } from './sync.js';

package/lib/manifest.d.ts

@@ -0,0 +1,24 @@
+export interface PatchEntry {
+    /** The package's own `package.json` name. */
+    name: string;
+    /** The exact upstream version the patch applies to. */
+    version: string;
+    description: string;
+    /** Issues the patch fixes, as `owner/repo#n`. */
+    fixes?: string[];
+    /**
+     * Dependency ranges the patch changes in `package.json`, written by `refresh commit`. npm resolves
+     * dependencies before `patchbay apply` runs, so sync passes these to npm as nested overrides.
+     */
+    dependencies?: Record<string, string>;
+}
+export interface Manifest {
+    patches: PatchEntry[];
+    /** Dependency names installed as another patched package, e.g. `koishi` → `@koishijs/core`. */
+    aliases: Record<string, string>;
+}
+export declare const ROOT: string;
+export declare function loadManifest(): Manifest;
+/** `@satorijs/core` + `4.6.1` → `@satorijs+core@4.6.1.patch`, the file name under `patches/`. */
+export declare function patchFileName(entry: Pick<PatchEntry, 'name' | 'version'>): string;
+export declare function patchPath(entry: Pick<PatchEntry, 'name' | 'version'>): string;

package/lib/manifest.js

@@ -0,0 +1,13 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+export const ROOT = fileURLToPath(new URL('..', import.meta.url));
+export function loadManifest() {
+    return JSON.parse(readFileSync(new URL('../patchbay.json', import.meta.url), 'utf8'));
+}
+/** `@satorijs/core` + `4.6.1` → `@satorijs+core@4.6.1.patch`, the file name under `patches/`. */
+export function patchFileName(entry) {
+    return `${entry.name.replace('/', '+')}@${entry.version}.patch`;
+}
+export function patchPath(entry) {
+    return fileURLToPath(new URL(`../patches/${patchFileName(entry)}`, import.meta.url));
+}

package/lib/patch.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Apply a git-style unified diff to a package directory, or undo it with `reverse`. Every file is
+ * checked before any is written, so a patch that does not fit leaves the directory untouched.
+ */
+export declare function applyPatchText(dir: string, text: string, { reverse }?: {
+    reverse?: boolean | undefined;
+}): void;

package/lib/patch.js

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { applyPatch, parsePatch, reversePatch } from 'diff';
+/** Strip the `a/` / `b/` prefix git diffs put on paths; `/dev/null` stays as is. */
+function stripPrefix(path) {
+    if (path === undefined || path === '/dev/null')
+        return path;
+    return path.replace(/^[ab]\//, '');
+}
+/**
+ * Apply a git-style unified diff to a package directory, or undo it with `reverse`. Every file is
+ * checked before any is written, so a patch that does not fit leaves the directory untouched.
+ */
+export function applyPatchText(dir, text, { reverse = false } = {}) {
+    const parsed = parsePatch(text);
+    const writes = [];
+    for (const file of reverse ? reversePatch(parsed) : parsed) {
+        const from = stripPrefix(file.oldFileName);
+        const to = stripPrefix(file.newFileName);
+        const target = to === '/dev/null' ? from : to;
+        if (target === undefined)
+            continue;
+        const path = join(dir, target);
+        if (to === '/dev/null') {
+            writes.push({ path, content: undefined });
+            continue;
+        }
+        const original = from === '/dev/null' ? '' : readFileSync(join(dir, from ?? target), 'utf8');
+        const result = applyPatch(original, file);
+        if (result === false)
+            throw new Error(`patch does not apply to ${target}`);
+        writes.push({ path, content: result });
+    }
+    for (const { path, content } of writes) {
+        if (content === undefined) {
+            rmSync(path, { force: true });
+            continue;
+        }
+        if (!existsSync(dirname(path)))
+            mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, content);
+    }
+}

package/lib/sync.d.ts

@@ -0,0 +1,31 @@
+import { type Manifest } from './manifest.ts';
+export type PackageManager = 'yarn' | 'pnpm' | 'npm';
+/** Project directory that holds the synced patch files and the manifest they came from. */
+export declare const STATE_DIR = ".patchbay";
+export interface PackageJson {
+    name?: string;
+    version?: string;
+    packageManager?: string;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    resolutions?: Record<string, string>;
+    overrides?: Record<string, unknown>;
+}
+export interface SyncOptions {
+    /** Skip detection and write for this package manager. */
+    pm?: PackageManager;
+}
+export declare function isPackageManager(value: unknown): value is PackageManager;
+export declare function readPackageJson(dir: string): PackageJson;
+/** The project's package manager: `packageManager`, then lockfiles, then the running one, then npm. */
+export declare function detect(dir: string): PackageManager;
+export declare function readState(dir: string): Manifest | undefined;
+/**
+ * Copy the patches into `<dir>/.patchbay` and point the project's package manager at them: yarn
+ * `resolutions`, pnpm `overrides` + `patchedDependencies`, or npm `overrides` + a `patchbay apply`
+ * postinstall. Entries a previous sync wrote are replaced, so upgrading patchbay drops stale pins.
+ */
+export declare function sync(dir: string, options?: SyncOptions): PackageManager;

package/lib/sync.js

@@ -0,0 +1,144 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Document, parseDocument } from 'yaml';
+import { loadManifest, patchFileName, patchPath } from './manifest.js';
+/** Project directory that holds the synced patch files and the manifest they came from. */
+export const STATE_DIR = '.patchbay';
+export function isPackageManager(value) {
+    return value === 'yarn' || value === 'pnpm' || value === 'npm';
+}
+export function readPackageJson(dir) {
+    return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+}
+function editPackageJson(dir, edit) {
+    const path = join(dir, 'package.json');
+    const text = readFileSync(path, 'utf8');
+    const pkg = JSON.parse(text);
+    edit(pkg);
+    writeFileSync(path, JSON.stringify(pkg, null, /^[ \t]+/m.exec(text)?.[0] ?? 2) + '\n');
+}
+function checkVersion(pm, major) {
+    if (pm === 'yarn' && major < 2)
+        throw new Error('Yarn 1 has no patch support; use Yarn 2+, pnpm 10+ or npm');
+    if (pm === 'pnpm' && major < 10)
+        throw new Error('pnpm reads patches from pnpm-workspace.yaml only since 10; upgrade pnpm');
+    if (!isPackageManager(pm))
+        throw new Error(`unknown package manager ${pm}`);
+    return pm;
+}
+/** The project's package manager: `packageManager`, then lockfiles, then the running one, then npm. */
+export function detect(dir) {
+    const declared = /^(yarn|pnpm|npm)@(\d+)/.exec(readPackageJson(dir).packageManager ?? '');
+    if (declared)
+        return checkVersion(declared[1], Number(declared[2]));
+    if (existsSync(join(dir, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(dir, '.yarnrc.yml')))
+        return 'yarn';
+    const yarnLock = join(dir, 'yarn.lock');
+    if (existsSync(yarnLock))
+        return checkVersion('yarn', readFileSync(yarnLock, 'utf8').includes('__metadata:') ? 2 : 1);
+    if (existsSync(join(dir, 'package-lock.json')))
+        return 'npm';
+    const agent = /^(yarn|pnpm|npm)\/(\d+)/.exec(process.env['npm_config_user_agent'] ?? '');
+    if (agent)
+        return checkVersion(agent[1], Number(agent[2]));
+    return 'npm';
+}
+function find(manifest, name) {
+    const entry = manifest.patches.find((item) => item.name === name);
+    if (!entry)
+        throw new Error(`alias target ${name} is not in patchbay.json`);
+    return entry;
+}
+/** Every top-level dependency name a manifest pins: patched packages plus their aliases. */
+function pinned(manifest) {
+    return new Map([
+        ...manifest.patches.map((entry) => [entry.name, entry]),
+        ...Object.entries(manifest.aliases).map(([alias, name]) => [alias, find(manifest, name)])
+    ]);
+}
+function npmSpec(name, entry) {
+    return name === entry.name ? entry.version : `npm:${entry.name}@${entry.version}`;
+}
+function writeYarn(dir, manifest, previous) {
+    editPackageJson(dir, (pkg) => {
+        const resolutions = { ...pkg.resolutions };
+        for (const name of previous ? pinned(previous).keys() : [])
+            delete resolutions[name];
+        for (const [name, entry] of pinned(manifest)) {
+            resolutions[name] = `patch:${entry.name}@npm%3A${entry.version}#~/${STATE_DIR}/${patchFileName(entry)}`;
+        }
+        pkg.resolutions = resolutions;
+    });
+}
+function writePnpm(dir, manifest, previous) {
+    const path = join(dir, 'pnpm-workspace.yaml');
+    const doc = existsSync(path) ? parseDocument(readFileSync(path, 'utf8')) : new Document({});
+    for (const [name, entry] of previous ? pinned(previous) : []) {
+        doc.deleteIn(['overrides', name]);
+        doc.deleteIn(['patchedDependencies', `${entry.name}@${entry.version}`]);
+    }
+    for (const [name, entry] of pinned(manifest))
+        doc.setIn(['overrides', name], npmSpec(name, entry));
+    for (const entry of manifest.patches) {
+        doc.setIn(['patchedDependencies', `${entry.name}@${entry.version}`], `${STATE_DIR}/${patchFileName(entry)}`);
+    }
+    // The manifest pins every patch it ships; a project uses only some of them.
+    doc.set('allowUnusedPatches', true);
+    writeFileSync(path, doc.toString());
+}
+function writeNpm(dir, manifest, previous) {
+    editPackageJson(dir, (pkg) => {
+        const overrides = { ...pkg.overrides };
+        for (const name of previous ? pinned(previous).keys() : [])
+            delete overrides[name];
+        const specs = pinned(manifest);
+        for (const [name, entry] of specs) {
+            // Ranges the patch changes would otherwise resolve from the unpatched package.json.
+            overrides[name] = entry.dependencies ? { '.': npmSpec(name, entry), ...entry.dependencies } : npmSpec(name, entry);
+        }
+        pkg.overrides = overrides;
+        // npm rejects an override that differs from a direct dependency's own spec (EOVERRIDE).
+        for (const deps of [pkg.dependencies, pkg.devDependencies, pkg.optionalDependencies]) {
+            for (const name of Object.keys(deps ?? {})) {
+                const entry = specs.get(name);
+                if (deps && entry)
+                    deps[name] = npmSpec(name, entry);
+            }
+        }
+        const postinstall = pkg.scripts?.['postinstall'];
+        if (postinstall?.includes('patchbay apply'))
+            return;
+        pkg.scripts = { ...pkg.scripts, postinstall: postinstall ? `${postinstall} && patchbay apply` : 'patchbay apply' };
+    });
+}
+export function readState(dir) {
+    const path = join(dir, STATE_DIR, 'patchbay.json');
+    if (!existsSync(path))
+        return;
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+/**
+ * Copy the patches into `<dir>/.patchbay` and point the project's package manager at them: yarn
+ * `resolutions`, pnpm `overrides` + `patchedDependencies`, or npm `overrides` + a `patchbay apply`
+ * postinstall. Entries a previous sync wrote are replaced, so upgrading patchbay drops stale pins.
+ */
+export function sync(dir, options = {}) {
+    const pm = options.pm ?? detect(dir);
+    const manifest = loadManifest();
+    const previous = readState(dir);
+    const state = join(dir, STATE_DIR);
+    rmSync(state, { recursive: true, force: true });
+    mkdirSync(state);
+    for (const entry of manifest.patches)
+        copyFileSync(patchPath(entry), join(state, patchFileName(entry)));
+    writeFileSync(join(state, 'patchbay.json'), JSON.stringify(manifest, null, 2) + '\n');
+    if (pm === 'yarn')
+        writeYarn(dir, manifest, previous);
+    else if (pm === 'pnpm')
+        writePnpm(dir, manifest, previous);
+    else
+        writeNpm(dir, manifest, previous);
+    return pm;
+}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@chatluna/patchbay",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Cordis 4 patches for Koishi, Satori, Satori adapters and Cordis plugins, wired into yarn, pnpm or npm",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ChatLunaLab/patchbay.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ChatLunaLab/patchbay/issues"
+  },
+  "keywords": [
+    "cordis",
+    "koishi",
+    "satori",
+    "patch",
+    "chatluna"
+  ],
+  "bin": "lib/cli.js",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "patches",
+    "patchbay.json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "yarn build && node --test tests/*.test.ts",
+    "verify": "node scripts/refresh.ts verify",
+    "refresh": "node scripts/refresh.ts",
+    "prepack": "yarn build"
+  },
+  "dependencies": {
+    "diff": "^8.0.2",
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.3",
+    "typescript": "7.0.2"
+  },
+  "packageManager": "yarn@4.18.0"
+}

package/patchbay.json

@@ -0,0 +1,68 @@
+{
+  "patches": [
+    {
+      "name": "@cordisjs/plugin-cli-cordis",
+      "version": "1.0.5",
+      "description": "Stable root include id, launcher include overrides and IPC health pings"
+    },
+    {
+      "name": "@cordisjs/plugin-database",
+      "version": "4.1.1",
+      "description": "Prepare tables extended while the driver was still starting; also installed as minato"
+    },
+    {
+      "name": "@cordisjs/plugin-http",
+      "version": "1.5.2",
+      "description": "Use resolveIntercept, which Cordis 4 renamed from resolveConfig"
+    },
+    {
+      "name": "@cordisjs/plugin-loader",
+      "version": "1.0.0-rc.9",
+      "description": "Load prelude entries first and plugins one at a time"
+    },
+    {
+      "name": "@cordisjs/plugin-server",
+      "version": "1.7.0",
+      "description": "Use resolveIntercept, which Cordis 4 renamed from resolveConfig"
+    },
+    {
+      "name": "@cordisjs/unyaml",
+      "version": "2.0.3",
+      "description": "Register the Vite YAML plugin through rolldownOptions instead of the retired esbuildOptions"
+    },
+    {
+      "name": "@koishijs/core",
+      "version": "4.18.11",
+      "description": "Run Koishi on Cordis 4; also installed as koishi. Inject shapes are normalized by the @satorijs/core patch",
+      "fixes": [
+        "ChatLunaLab/boilerplate#12"
+      ],
+      "dependencies": {
+        "cordis": "^4.0.0-rc.8"
+      }
+    },
+    {
+      "name": "@satorijs/core",
+      "version": "4.6.1",
+      "description": "Run Satori and its adapters on Cordis 4: { required, optional } inject, ready/dispose events, Koishi 4 service lookups, a Quester-compatible http and a Koa-style server for adapter fibers",
+      "fixes": [
+        "ChatLunaLab/v2-mirror#14",
+        "ChatLunaLab/boilerplate#12",
+        "ChatLunaLab/boilerplate#13"
+      ],
+      "dependencies": {
+        "@cordisjs/plugin-http": "^1.5.1",
+        "cordis": "^4.0.0-rc.8"
+      }
+    },
+    {
+      "name": "koishi-plugin-adapter-onebot",
+      "version": "6.9.5",
+      "description": "Import Satori directly and inject http, satori and timer"
+    }
+  ],
+  "aliases": {
+    "koishi": "@koishijs/core",
+    "minato": "@cordisjs/plugin-database"
+  }
+}

package/patches/@cordisjs+plugin-cli-cordis@1.0.5.patch

@@ -0,0 +1,56 @@
+diff --git a/lib/worker/index.d.ts b/lib/worker/index.d.ts
+index 4362cf8..ae92999 100644
+--- a/lib/worker/index.d.ts
++++ b/lib/worker/index.d.ts
+@@ -4,6 +4,10 @@ export interface Config {
+     baseUrl?: string;
+     execArgv?: string[];
+     path: string;
++    /** Fixed id for the root include entry; defaults to 'chatluna' (keeps tree ids stable). */
++    includeId?: string;
++    /** Override/extend the root include config (e.g. inject `patches` to enable a group). */
++    include?: Record<string, unknown>;
+     daemon: daemon.Config;
+     prelude?: EntryOptions[];
+ }
+diff --git a/lib/worker/index.js b/lib/worker/index.js
+index 91ff829..ec55279 100644
+--- a/lib/worker/index.js
++++ b/lib/worker/index.js
+@@ -31,6 +31,12 @@ function* apply(ctx, config = {}) {
+   process.on("SIGTERM", handleSignal);
+   yield () => process.off("SIGTERM", handleSignal);
+   process.send({ type: "start", body: config });
++  // Health over IPC: the supervisor pings, the worker answers; no network address involved.
++  const onMessage = /* @__PURE__ */ __name((message) => {
++    if (message?.type === "ping") process.send({ type: "pong", id: message.id });
++  }, "onMessage");
++  process.on("message", onMessage);
++  yield () => process.off("message", onMessage);
+   if (config.heartbeatInterval) {
+     const timer = setInterval(() => {
+       process.send({ type: "heartbeat" });
+@@ -59,12 +65,22 @@ async function start(config) {
+     await ctx.loader.create(plugin);
+   }
+   await ctx.loader.create({
++    // Fixed id so tree-side entries keep stable ids (chatluna:<id>) across restarts.
++    id: config.includeId ?? "chatluna",
+     name: "@cordisjs/plugin-include",
+     config: {
++      // `include` lets the launcher override the include config wholesale (e.g.
++      // `chatluna dev` injects a `patches` entry to enable the dev group).
+       path: config.path,
+-      enableLogs: true
++      enableLogs: true,
++      ...config.include
+     }
+   });
++  // Ready once every entry has finished loading (failed plugins included; they are logged).
++  if (config.daemon.enabled) {
++    await ctx.loader.await();
++    process.send({ type: "ready" });
++  }
+ }
+ __name(start, "start");
+ export {