@chatluna/patchbay 0.0.0-stage → 0.1.1

package/patches/@satorijs+core@4.6.1.patch

@@ -0,0 +1,584 @@
+diff --git a/lib/index.d.ts b/lib/index.d.ts
+index 642da25..b39b250 100644
+--- a/lib/index.d.ts
++++ b/lib/index.d.ts
+@@ -1,8 +1,9 @@
+-import { Context, Service, z, Logger } from 'cordis';
++import { Context, Service, Logger } from 'cordis';
++import { default as z } from 'schemastery';
+ import { Message, SendOptions, Event, GuildMember, User, Meta, Response, Login, Methods, Status, Upload, WebSocket } from '@satorijs/protocol';
+ import h from '@satorijs/element';
+ import { Awaitable, Dict } from 'cosmokit';
+-import { HTTP } from '@cordisjs/plugin-http';
++import { Http, Http as HTTP } from '@cordisjs/plugin-http';
+ import { Key } from 'path-to-regexp';
+ export abstract class MessageEncoder<C extends Context = Context, B extends Bot<C> = Bot<C>> {
+     bot: B;
+@@ -49,7 +50,7 @@ export class Session<C extends Context = Context> {
+     id: number;
+     sn: number;
+     bot: Bot<C>;
+-    app: C['root'];
++    app: C[typeof Context.root];
+     event: Event;
+     locales: string[];
+     constructor(bot: Bot<C>, event: Partial<Event>);
+@@ -73,7 +74,7 @@ export class Session<C extends Context = Context> {
+ }
+ export function defineAccessor(prototype: {}, name: string, keys: string[]): void;
+ export type { Fragment, Render } from '@satorijs/element';
+-export { h, h as Element, h as segment, HTTP, HTTP as Quester };
++export { h, h as Element, h as segment, Http, Http as HTTP, Http as Quester };
+ export * from 'cordis';
+ export * from 'cosmokit';
+ export * as Universal from '@satorijs/protocol';
+@@ -129,7 +130,7 @@ declare module 'cordis' {
+ }
+ declare module '@cordisjs/plugin-http' {
+     namespace HTTP {
+-        function createConfig(this: typeof HTTP, endpoint?: string | boolean): z<Config>;
++        function createConfig(this: typeof Http, endpoint?: string | boolean): z<Config>;
+     }
+ }
+ export type Component<S extends Session = Session> = h.Render<Awaitable<h.Fragment>, S>;
+@@ -138,7 +139,7 @@ export namespace Component {
+         session?: boolean;
+     }
+ }
+-export type GetSession<C extends Context> = C[typeof Context.session];
++export type GetSession<C extends Context> = Session;
+ declare class SatoriContext extends Context {
+     constructor(config?: any);
+ }
+@@ -152,7 +153,7 @@ declare class DisposableSet<T> {
+     add(...values: T[]): () => void;
+     [Symbol.iterator](): SetIterator<T>;
+ }
+-export class Satori<C extends Context = Context> extends Service<unknown, C> {
++export class Satori<C extends Context = Context> extends Service {
+     static [Service.provide]: string;
+     static [Service.immediate]: boolean;
+     uid: string;
+@@ -222,6 +223,7 @@ export abstract class Bot<C extends Context = Context, T = any> {
+     config: T;
+     adapterName: string;
+     static reusable: boolean;
++    static inject: string[];
+     static MessageEncoder?: new (bot: Bot, channelId: string, referrer?: any, options?: SendOptions) => MessageEncoder;
+     [Service.tracker]: {
+         associate: string;
+diff --git a/lib/index.mjs b/lib/index.mjs
+index 79916ba..93a2e63 100644
+--- a/lib/index.mjs
++++ b/lib/index.mjs
+@@ -2,7 +2,276 @@ var __defProp = Object.defineProperty;
+ var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+ 
+ // src/index.ts
+-import { Context as Context4, Logger as Logger2, Service as Service4, z as z2 } from "cordis";
++import { Context as Context4, Inject, RegistryService, Service as Service4, getTraceable } from "cordis";
++import Schema4 from "schemastery";
++// Module-level loggers lack a Context; forward to the host target or console until upstream supports Cordis 4.
++class SatoriLoggerShim {
++  static target = null;
++  #name;
++  constructor(name) { this.#name = name; }
++  _log(level, ...args) {
++    if (SatoriLoggerShim.target) SatoriLoggerShim.target({ level, name: this.#name, args });
++    else if (level === "error") console.error(`[${this.#name}]`, ...args);
++    else if (level === "warn") console.warn(`[${this.#name}]`, ...args);
++    else console.log(`[${this.#name}]`, ...args);
++  }
++  debug(...args) { this._log("debug", ...args); }
++  info(...args) { this._log("info", ...args); }
++  warn(...args) { this._log("warn", ...args); }
++  error(...args) { this._log("error", ...args); }
++}
++const Logger2 = SatoriLoggerShim;
++const z2 = Schema4;
++// Cordis 4 has no ready event; use the fiber state transition.
++function onReady(ctx, cb) {
++  if (ctx.fiber.state === 2) {
++    const timer = setTimeout(cb, 0);
++    return () => clearTimeout(timer);
++  }
++  const off = ctx.on("internal/status", (fiber) => {
++    if (fiber === ctx.fiber && fiber.state === 2) { off(); Promise.resolve().then(cb); }
++  });
++  return off;
++}
++// Satori and Koishi plugins declare `inject = { required, optional }`, but Cordis 4 reads every key of
++// an inject object as a service name, so such a plugin waits forever for services named "required"
++// and "optional". Normalize the shape where Cordis resolves it, at module load so no plugin can be
++// registered first. Optional names are kept for the internal/get hook in the Satori service, and Bot
++// and Adapter plugins also wait for `satori`, which every Bot constructor reads.
++const kOptional = Symbol.for("satori.cordis4.optional");
++let resolving;
++if (!Object.hasOwn(RegistryService.prototype, kOptional)) {
++  Object.defineProperty(RegistryService.prototype, kOptional, { value: true });
++  const plugin = RegistryService.prototype.plugin;
++  RegistryService.prototype.plugin = function(target, ...args) {
++    const outer = resolving;
++    resolving = target;
++    try {
++      return plugin.call(this, target, ...args);
++    } finally {
++      resolving = outer;
++    }
++  };
++  const resolve = Inject.resolve;
++  Inject.resolve = function(inject, result) {
++    const shaped = !!inject && !Array.isArray(inject) && (Array.isArray(inject.required) || Array.isArray(inject.optional));
++    const resolved = resolve(shaped ? inject.required ?? [] : inject, result);
++    if (shaped) Object.defineProperty(resolved, kOptional, { value: inject.optional ?? [] });
++    const proto = resolving?.prototype;
++    if ((proto instanceof Bot || proto instanceof Adapter) && !("satori" in resolved)) resolved.satori = null;
++    return resolved;
++  };
++}
++function isOptional(fiber, name) {
++  for (; fiber; fiber = fiber.runtime && fiber.parent.fiber) {
++    if (fiber.inject[kOptional]?.includes(name)) return true;
++  }
++  return false;
++}
++const satoriFibers = /* @__PURE__ */ new WeakMap();
++function isSatoriFiber(fiber) {
++  if (!fiber.runtime) return false;
++  let result = satoriFibers.get(fiber);
++  if (result !== void 0) return result;
++  const proto = fiber.runtime.callback.prototype;
++  result = proto instanceof Bot || proto instanceof Adapter || isSatoriFiber(fiber.parent.fiber);
++  satoriFibers.set(fiber, result);
++  return result;
++}
++// Satori adapters are written against the Quester client of Cordis 3: `http(url)` resolves to
++// `{ data, status, headers }` and throws on 4xx/5xx, `endpoint` is joined as a string prefix, and
++// `file()` / `isLocal()` exist. @cordisjs/plugin-http 1.x returns a raw Response, never throws on
++// status, uses `baseUrl` and has neither helper. Adapter fibers see this facade over it instead.
++const trimSlash = /* @__PURE__ */ __name((source) => source.replace(/\/$/, ""), "trimSlash");
++const questers = /* @__PURE__ */ new WeakMap();
++let localAddresses;
++function toQuester(http, endpoint) {
++  if (endpoint === void 0 && questers.has(http)) return questers.get(http);
++  const resolveUrl = /* @__PURE__ */ __name((url) => {
++    if (!endpoint || typeof url !== "string" || URL.canParse(url)) return url;
++    return trimSlash(endpoint) + url;
++  }, "resolveUrl");
++  const request = /* @__PURE__ */ __name(async function(...args) {
++    const method = typeof args[1] === "string" || args[1] instanceof URL ? args.shift() : void 0;
++    const { validateStatus = /* @__PURE__ */ __name((status) => status < 400, "validateStatus"), ...config } = args[1] ?? {};
++    const raw = await http(resolveUrl(args[0]), { ...config, method: method ?? config.method });
++    const response = { data: null, url: raw.url, status: raw.status, statusText: raw.statusText, headers: raw.headers };
++    if (!validateStatus(raw.status)) {
++      response.data = await http.defaultDecoder(raw).catch(() => null);
++      throw new Http.Error(raw.statusText, "STATUS_ERROR", response);
++    }
++    response.data = await http._decode(raw);
++    return response;
++  }, "request");
++  const methods = {
++    get: /* @__PURE__ */ __name((url, config) => request(url, { method: "GET", ...config }).then((r) => r.data), "get"),
++    delete: /* @__PURE__ */ __name((url, config) => request(url, { method: "DELETE", ...config }).then((r) => r.data), "delete"),
++    patch: /* @__PURE__ */ __name((url, data, config) => request(url, { method: "PATCH", data, ...config }).then((r) => r.data), "patch"),
++    post: /* @__PURE__ */ __name((url, data, config) => request(url, { method: "POST", data, ...config }).then((r) => r.data), "post"),
++    put: /* @__PURE__ */ __name((url, data, config) => request(url, { method: "PUT", data, ...config }).then((r) => r.data), "put"),
++    head: /* @__PURE__ */ __name((url, config) => request(url, { method: "HEAD", ...config }).then((r) => r.headers), "head"),
++    ws: /* @__PURE__ */ __name((url, config) => http.ws(resolveUrl(url), config), "ws"),
++    extend: /* @__PURE__ */ __name((config = {}) => {
++      const { endpoint: next = endpoint, baseURL, ...rest } = config;
++      return toQuester(http.extend(baseURL === void 0 ? rest : { ...rest, baseUrl: baseURL }), next);
++    }, "extend"),
++    isError: Http.Error.is,
++    file: /* @__PURE__ */ __name(async (_url, options = {}) => {
++      const url = resolveUrl(_url);
++      const task = await http.ctx.serial(facade, "http/file", url, options);
++      if (task) return task;
++      const { headers, data, url: responseUrl } = await request(url, {
++        method: "GET",
++        responseType: "arraybuffer",
++        timeout: +options.timeout || void 0
++      });
++      const type = headers.get("content-type") ?? void 0;
++      // A data: URL response has no url to take a name from.
++      const filename = /.+\/([^/?]*)(?=\?)?/.exec(responseUrl)?.[1] || `file.${type?.split("/")[1]?.split(/[;+]/)[0] ?? "bin"}`;
++      return { type, mime: type, filename, data };
++    }, "file"),
++    isLocal: /* @__PURE__ */ __name(async (url) => {
++      const { hostname, protocol } = new URL(url);
++      if (protocol !== "http:" && protocol !== "https:") return true;
++      const [{ lookup }, { BlockList }] = await Promise.all([import("node:dns/promises"), import("node:net")]);
++      if (!localAddresses) {
++        localAddresses = new BlockList();
++        for (const range of ["0.0.0.0/8", "10.0.0.0/8", "100.64.0.0/10", "127.0.0.0/8", "169.254.0.0/16", "172.16.0.0/12", "192.0.0.0/24", "192.0.2.0/24", "192.168.0.0/16", "198.18.0.0/15", "198.51.100.0/24", "203.0.113.0/24", "224.0.0.0/3"]) {
++          const [address, prefix] = range.split("/");
++          localAddresses.addSubnet(address, +prefix, "ipv4");
++        }
++        for (const range of ["::/128", "::1/128", "64:ff9b::/96", "100::/64", "2001:db8::/32", "fc00::/7", "fe80::/10", "ff00::/8"]) {
++          const [address, prefix] = range.split("/");
++          localAddresses.addSubnet(address, +prefix, "ipv6");
++        }
++      }
++      try {
++        const { address, family } = await lookup(hostname.replace(/^\[(.+)\]$/, "$1"));
++        return localAddresses.check(address, family === 6 ? "ipv6" : "ipv4");
++      } catch {
++        return false;
++      }
++    }, "isLocal")
++  };
++  const facade = new Proxy(request, {
++    get(target, prop) {
++      // Symbols stay local: forwarding the client's tracker or invoke symbol would make Cordis
++      // trace this facade as the raw client.
++      if (typeof prop === "symbol") return Reflect.get(target, prop);
++      if (Object.hasOwn(methods, prop)) return methods[prop];
++      if (prop === "config") return { ...http.config, endpoint };
++      const value = Reflect.get(http, prop);
++      return typeof value === "function" ? value.bind(http) : value;
++    }
++  });
++  if (endpoint === void 0) questers.set(http, facade);
++  return facade;
++}
++// Satori adapters register Koa routes: `ctx.server.post(path, (koa, next) => ...)` reading a parsed
++// `koa.request.body` (raw text under `Symbol.for("unparsedBody")`) and writing `koa.status` /
++// `koa.body`, with koa-router paths and `config.selfUrl`. @cordisjs/plugin-server 1.x passes its own
++// Request and Response, parses nothing, matches path-to-regexp 8 paths and calls it `baseUrl`.
++const kUnparsed = Symbol.for("unparsedBody");
++const koaServers = /* @__PURE__ */ new WeakMap();
++// koa-router paths use path-to-regexp 6 modifiers (adapter-telegram serves `/:file+`); plugin-server
++// compiles path-to-regexp 8, which spells them as wildcards and braces, and has no inline groups.
++const koaPath = /* @__PURE__ */ __name((path) => {
++  if (typeof path !== "string") return path;
++  if (path.includes("(")) return new RegExp(`^${path}$`);
++  return path.replace(/\/:(\w+)([+*?])/g, (_, name, modifier) => modifier === "+" ? `/*${name}` : modifier === "*" ? `{/*${name}}` : `{/:${name}}`);
++}, "koaPath");
++async function toKoaContext(req, res) {
++  const type = req.headers.get("content-type") ?? "";
++  const raw = req.method === "GET" || req.method === "HEAD" ? "" : await req.text();
++  let body = {};
++  if (raw && type.includes("json")) body = JSON.parse(raw);
++  else if (raw && type.includes("x-www-form-urlencoded")) body = Object.fromEntries(new URLSearchParams(raw));
++  else if (raw) body = raw;
++  if (typeof body === "object") Object.defineProperty(body, kUnparsed, { value: raw });
++  const headers = Object.fromEntries(req.headers);
++  const query = Object.fromEntries(req.query);
++  let status, payload;
++  const koa = {
++    req: { method: req.method, url: req.url, headers },
++    method: req.method,
++    path: req.path,
++    url: req.url,
++    query,
++    params: req.params,
++    headers,
++    header: headers,
++    request: {
++      body,
++      method: req.method,
++      path: req.path,
++      url: req.url,
++      query,
++      headers,
++      header: headers,
++      is: /* @__PURE__ */ __name((...types) => types.find((name) => type.includes(name)) ?? false, "is")
++    },
++    response: {
++      get status() { return koa.status; },
++      set status(value) { koa.status = value; },
++      get body() { return koa.body; },
++      set body(value) { koa.body = value; },
++      set type(value) { koa.type = value; }
++    },
++    get status() { return status ?? 404; },
++    set status(value) { status = value; },
++    // adapter-onebot reads the parsed request from `ctx.body` until it writes a response.
++    get body() { return payload ?? body; },
++    set body(value) {
++      payload = value;
++      status ??= 200;
++    },
++    set type(value) { res.headers.set("content-type", value); },
++    get: /* @__PURE__ */ __name((field) => req.headers.get(field) ?? "", "get"),
++    set: /* @__PURE__ */ __name((field, value) => {
++      if (typeof field === "string") return res.headers.set(field, value);
++      for (const [key, item] of Object.entries(field)) res.headers.set(key, item);
++    }, "set")
++  };
++  const flush = /* @__PURE__ */ __name(() => {
++    if (status !== void 0) res.status = status;
++    if (payload === void 0) return;
++    const binary = typeof payload !== "object" || payload === null || ArrayBuffer.isView(payload) || payload instanceof ArrayBuffer || payload instanceof Blob || payload instanceof ReadableStream;
++    if (binary) res.body = payload;
++    else res.json(payload);
++  }, "flush");
++  return [koa, flush];
++}
++function toKoaServer(server) {
++  if (koaServers.has(server)) return koaServers.get(server);
++  const route = /* @__PURE__ */ __name((method) => (path, middleware, options) => server[method](koaPath(path), async (req, res, next) => {
++    const [koa, flush] = await toKoaContext(req, res);
++    let forwarded;
++    await middleware(koa, () => forwarded = next());
++    if (forwarded) return forwarded;
++    flush();
++  }, options), "route");
++  const methods = {
++    ...Object.fromEntries(["all", "get", "delete", "head", "post", "put", "patch"].map((method) => [method, route(method)])),
++    ws: /* @__PURE__ */ __name((path, handle, options) => {
++      const layer = server.ws(koaPath(path), handle && (async (req, accept) => {
++        return handle(await accept(), { method: req.method, url: req.url, headers: Object.fromEntries(req.headers) });
++      }), options);
++      return Object.assign(layer, { close: /* @__PURE__ */ __name(() => layer.dispose(), "close") });
++    }, "ws")
++  };
++  const facade = new Proxy(server, {
++    get(target, prop) {
++      if (typeof prop === "symbol") return Reflect.get(target, prop);
++      if (Object.hasOwn(methods, prop)) return methods[prop];
++      if (prop === "selfUrl") return server.baseUrl;
++      if (prop === "config") return { ...server.config, selfUrl: server.baseUrl };
++      const value = Reflect.get(server, prop);
++      return typeof value === "function" ? value.bind(server) : value;
++    }
++  });
++  koaServers.set(server, facade);
++  return facade;
++}
+ import { defineProperty as defineProperty2 } from "cosmokit";
+ 
+ // src/internal.ts
+@@ -121,9 +390,11 @@ var JsonForm;
+ })(JsonForm || (JsonForm = {}));
+ 
+ // src/index.ts
+-import { HTTP } from "@cordisjs/plugin-http";
++import { Http } from "@cordisjs/plugin-http";
+ import h3 from "@satorijs/element";
+ export * from "cordis";
++// Restore the removed Schema/z exports from Schemastery.
++export { Schema4 as Schema, Schema4 as z, SatoriLoggerShim as Logger };
+ export * from "cosmokit";
+ import * as Universal from "@satorijs/protocol";
+ 
+@@ -158,9 +429,8 @@ var Session = class {
+     this.event = event;
+     this.sn = this.id = ++bot.ctx.satori._sessionSeq;
+     defineProperty(this, "bot", bot);
+-    defineProperty(this, "app", bot.ctx.root);
+-    defineProperty(this, Context.current, bot.ctx);
+-    return Context.associate(this, "session");
++    defineProperty(this, "app", bot.ctx[Context4.root]);
++    return getTraceable(bot.ctx, this);
+   }
+   /** @deprecated */
+   get data() {
+@@ -299,12 +569,12 @@ var Bot = class {
+     this.logger = ctx.logger(adapterName);
+     this.platform = adapterName;
+     this.features = Object.entries(Methods).filter(([, value]) => this[value.name]).map(([key]) => key);
+-    ctx.on("ready", async () => {
++    onReady(ctx, async () => {
+       await Promise.resolve();
+       this.dispatchLoginEvent("login-added");
+       return this.start();
+     });
+-    ctx.on("dispose", () => this.dispose());
++    ctx.effect(() => () => this.dispose());
+     ctx.on("interaction/button", (session) => {
+       const cb = this.callbacks[session.event.button.id];
+       if (cb) cb(session);
+@@ -317,10 +587,12 @@ var Bot = class {
+     __name(this, "Bot");
+   }
+   static reusable = true;
++  static inject = ["satori"];
+   static MessageEncoder;
++  // No `property: "ctx"`: adapters read `bot.ctx.http` / `bot.ctx.server` from code another plugin
++  // calls, and those must resolve on the bot's own fiber, not the caller's.
+   [Service3.tracker] = {
+-    associate: "bot",
+-    property: "ctx"
++    associate: "bot"
+   };
+   sn;
+   user;
+@@ -414,7 +686,7 @@ var Bot = class {
+     return new Session(this, event);
+   }
+   dispatch(session) {
+-    if (!this.ctx.lifecycle.isActive) return;
++    if (this.ctx.fiber.state >= 4) return;
+     let events = [session.type];
+     for (const aliases of eventAliases) {
+       if (aliases.includes(session.type)) {
+@@ -468,7 +740,7 @@ var Bot = class {
+         delete this.ctx.satori._tempStore[id];
+       }
+     }, "dispose");
+-    const _dispose = this.ctx.on("dispose", dispose);
++    const _dispose = this.ctx.effect(() => dispose);
+     return ids.map((id) => this.getInternalUrl(`/_tmp/${id}`));
+   }
+   async supports(name, session = {}) {
+@@ -530,7 +802,7 @@ defineAccessor(Bot.prototype, "userId", ["user", "id"]);
+ // src/adapter.ts
+ import { remove as remove2, Time } from "cosmokit";
+ import { Status as Status2 } from "@satorijs/protocol";
+-import { z } from "cordis";
++import { default as z } from "schemastery";
+ var Adapter = class {
+   constructor(ctx) {
+     this.ctx = ctx;
+@@ -548,10 +820,15 @@ var Adapter = class {
+   fork(ctx, bot) {
+     bot.adapter = this;
+     this.bots.push(bot);
+-    ctx.on("dispose", () => {
++    ctx.effect(() => () => {
+       remove2(this.bots, bot);
+     });
+   }
++  // Cordis 4 never calls `fork`; fork the bot this adapter was mounted with once it is constructed.
++  [Symbol.for("cordis.init")]() {
++    const bot = this.ctx.fiber.config;
++    if (bot instanceof Bot && !this.bots.includes(bot)) return this.fork(this.ctx, bot);
++  }
+ };
+ ((Adapter2) => {
+   Adapter2.WsClientConfig = z.object({
+@@ -614,7 +891,8 @@ var Adapter = class {
+         socket.addEventListener("open", () => {
+           retryCount = 0;
+           this.socket = socket;
+-          logger.info("connect to server: %c", url);
++          // Use %C under Cordis 4: %c consumes the value without rendering it.
++          logger.info("connect to server: %C", url);
+           this.accept(socket);
+         });
+       }, "connect");
+@@ -724,7 +1002,7 @@ var MessageEncoder = class {
+ 
+ // src/index.ts
+ h3.warn = new Logger2("element").warn;
+-HTTP.createConfig = /* @__PURE__ */ __name(function createConfig(endpoint) {
++Http.createConfig = /* @__PURE__ */ __name(function createConfig(endpoint) {
+   return z2.object({
+     endpoint: z2.string().role("link").description("要连接的服务器地址。").default(typeof endpoint === "string" ? endpoint : void 0).required(typeof endpoint === "boolean" ? endpoint : false),
+     headers: z2.dict(String).role("table").description("要附加的额外请求头。"),
+@@ -737,7 +1015,7 @@ var SatoriContext = class extends Context4 {
+   }
+   constructor(config) {
+     super(config);
+-    this.provide("satori", void 0, true);
++    // The Service constructor registers itself; pre-providing would conflict.
+     this.plugin(Satori);
+   }
+ };
+@@ -799,7 +1077,37 @@ var Satori = class extends Service4 {
+   _loginSeq = 0;
+   _sessionSeq = 0;
+   constructor(ctx) {
+-    super(ctx);
++    super(ctx, "satori");
++    // Cordis 4 dropped the ready and dispose events adapters still listen to; map both onto the fiber.
++    ctx.on("internal/listener", function(name, listener) {
++      if (name === "ready") return onReady(this, listener);
++      if (name !== "dispose") return;
++      let active = true;
++      const dispose = this.effect(() => () => active && listener());
++      return () => {
++        active = false;
++        dispose();
++      };
++    });
++    // Adapters were written for Koishi 4, which never enforced inject: adapter-onebot calls
++    // `bot.ctx.setTimeout` without injecting `timer`, so their lookups never throw here. Prepended so
++    // a host's own global lookup cannot hand an adapter the raw services first.
++    ctx.on("internal/get", (target, name, error, next) => {
++      return isSatoriFiber(target.fiber) || isOptional(target.fiber, name) ? target.get(name) : next();
++    }, { prepend: true });
++    // `ctx.get(name)` skips internal/get, and adapter-telegram reads `ctx.get("server")`.
++    const reflect = ctx.reflect.constructor.prototype;
++    if (!Object.hasOwn(reflect, kOptional)) {
++      Object.defineProperty(reflect, kOptional, { value: true });
++      const get = reflect.get;
++      reflect.get = function(name, strict) {
++        const value = get.call(this, name, strict);
++        if (value === void 0 || !isSatoriFiber(this.ctx.fiber)) return value;
++        if (name === "http") return toQuester(value);
++        if (name === "server") return toKoaServer(value);
++        return value;
++      };
++    }
+     ctx.mixin("satori", ["bots", "component"]);
+     defineProperty2(this.bots, Service4.tracker, {});
+     const self = this;
+@@ -871,6 +1179,8 @@ var Satori = class extends Service4 {
+       const result = await component(attrs, children, session);
+       return session.transform(h3.normalize(result));
+     }, "render");
++    // Cordis 4 `set` requires a declared property; provide it first, fiber-bound.
++    this.ctx.provide("component:" + name, render);
+     return this.ctx.set("component:" + name, render);
+   }
+   defineInternalRoute(path, callback) {
+@@ -900,13 +1210,14 @@ export {
+   Bot,
+   SatoriContext as Context,
+   h3 as Element,
+-  HTTP,
++  Http,
++  Http as HTTP,
+   InternalRouter,
+   JsonForm,
+   MessageEncoder,
+   MessageEncoder as Messenger,
+   MessageEncoder as Modulator,
+-  HTTP as Quester,
++  Http as Quester,
+   Satori,
+   Session,
+   Universal,
+diff --git a/package.json b/package.json
+index d3af7e0..d609a16 100644
+--- a/package.json
++++ b/package.json
+@@ -3,13 +3,13 @@
+   "description": "Core components of Satorijs",
+   "version": "4.6.1",
+   "type": "module",
+-  "main": "lib/index.cjs",
++  "main": "lib/index.mjs",
+   "module": "lib/index.mjs",
+   "types": "lib/index.d.ts",
+   "exports": {
+     ".": {
+       "types": "./lib/index.d.ts",
+-      "require": "./lib/index.cjs",
++      "require": "./lib/index.mjs",
+       "import": "./lib/index.mjs"
+     },
+     "./src/*": "./src/*",
+@@ -54,14 +54,15 @@
+     }
+   },
+   "peerDependencies": {
+-    "cordis": "^3.18.1"
++    "cordis": "^4.0.0-rc.7",
++    "@cordisjs/plugin-http": "^1.5.1"
+   },
+   "dependencies": {
+-    "@cordisjs/plugin-http": "^0.6.3",
+     "@satorijs/element": "^3.2.0",
+     "@satorijs/protocol": "^1.7.0",
+-    "cordis": "^3.18.1",
++    "cordis": "^4.0.0-rc.8",
+     "cosmokit": "^1.8.1",
+-    "path-to-regexp": "^8.2.0"
++    "path-to-regexp": "^8.2.0",
++    "schemastery": "^3.18.0"
+   }
+ }
+