@chatluna/patchbay 0.0.0-stage → 0.1.1

package/patches/@cordisjs+plugin-database@4.1.1.patch

@@ -0,0 +1,15 @@
+diff --git a/lib/index.js b/lib/index.js
+index 47b64a6..46865f0 100644
+--- a/lib/index.js
++++ b/lib/index.js
+@@ -985,6 +985,10 @@ var Database = class _Database extends Service {
+   migrateTasks = /* @__PURE__ */ Object.create(null);
+   constructor(ctx) {
+     super(ctx, "model");
++    // chatluna: `database` resolves only after the driver fiber is active, so tables extended while it started were skipped; prepare them now.
++    ctx.on("internal/service", (name) => {
++      if (name === "database") this.refresh();
++    });
+   }
+   refresh() {
+     for (const name in this.tables) {

package/patches/@cordisjs+plugin-http@1.5.2.patch

@@ -0,0 +1,13 @@
+diff --git a/lib/index.js b/lib/index.js
+index 3acbdff..56c9913 100644
+--- a/lib/index.js
++++ b/lib/index.js
+@@ -202,7 +202,7 @@ var Http = class _Http extends Service {
+     });
+   }
+   resolveConfig(init) {
+-    return this[Service.resolveConfig](this.config, init);
++    return { ...this[Service.resolveIntercept](), ...this.config, ...init };
+   }
+   resolveURL(url, config, isWebSocket = false) {
+     try {

package/patches/@cordisjs+plugin-loader@1.0.0-rc.9.patch

@@ -0,0 +1,82 @@
+diff --git a/lib/config/group.d.ts b/lib/config/group.d.ts
+index 2ae7a04..0ade21f 100644
+--- a/lib/config/group.d.ts
++++ b/lib/config/group.d.ts
+@@ -5,6 +5,7 @@ export declare class EntryGroup {
+     ctx: Context;
+     tree: EntryTree;
+     static readonly key: unique symbol;
++    static readonly prelude: unique symbol;
+     data: EntryOptions[];
+     constructor(ctx: Context, tree: EntryTree);
+     get context(): Context;
+diff --git a/lib/index.js b/lib/index.js
+index 1e2197d..688f658 100644
+--- a/lib/index.js
++++ b/lib/index.js
+@@ -175,6 +175,7 @@ var EntryGroup = class {
+     __name(this, "EntryGroup");
+   }
+   static key = /* @__PURE__ */ Symbol.for("cordis.group");
++  static prelude = /* @__PURE__ */ Symbol.for("cordis.loader.prelude");
+   data = [];
+   get context() {
+     return this.ctx;
+@@ -230,13 +231,33 @@ var EntryGroup = class {
+     const oldMap = Object.fromEntries(oldConfig.map((options) => [options?.id, options]));
+     const newMap = Object.fromEntries(config.map((options) => [options?.id ?? /* @__PURE__ */ Symbol("anonymous"), options]));
+     const ids = Reflect.ownKeys({ ...oldMap, ...newMap });
++    for (const id of ids) {
++      if (!newMap[id]) this.remove(id);
++    }
++    const prelude = new Set();
++    // Sequential: a CJS require() of an ESM module a parallel import() is still loading throws ERR_REQUIRE_ESM_RACE_CONDITION.
++    for (const options of config) {
++      if (options.disabled) continue;
++      let plugin;
++      try {
++        plugin = this.ctx.loader.unwrapExports(await this.tree.import(options.name));
++      } catch {
++        // Entry.init owns import-failure reporting with the outer stack.
++        continue;
++      }
++      if (!plugin?.[EntryGroup.prelude]) continue;
++      prelude.add(options);
++      const id = await this.create(options);
++      // group.create returns the fully qualified id; resolve() walks subtrees.
++      const fiber = this.ctx.loader.resolve(id)?.fiber;
++      await fiber?.await();
++      if (fiber?.state !== 2) throw new Error(`prelude entry ${id} is not active`);
++    }
+     await Promise.all(ids.map(async (id) => {
+-      if (newMap[id]) {
++      if (newMap[id] && !prelude.has(newMap[id])) {
+         await this.create(newMap[id]).catch((error) => {
+           this.ctx.logger.error(error);
+         });
+-      } else {
+-        this.remove(id);
+       }
+     }));
+   }
+@@ -864,14 +885,18 @@ var Loader = class extends EntryTree {
+       if (!fiber.entry || fiber.parent.fiber?.entry === fiber.entry) return config2;
+       sources.set(fiber, config2);
+       if (fiber.runtime.callback[EntryGroup.key]) return config2;
+-      return interpolate(fiber.ctx, config2);
++      const holder = { value: interpolate(fiber.ctx, config2) };
++      this.ctx.emit("loader/resolve-config", fiber.entry, holder);
++      return holder.value;
+     });
+     ctx.on("internal/commit", (fiber, config2) => {
+       if (!fiber.entry || fiber.parent.fiber?.entry === fiber.entry) return;
+       const unparse = fiber.runtime?.Config?.["simplify"];
+       const { entry } = fiber;
+       const legacy = { ...entry.options };
+-      entry.options.config = unparse ? unparse(config2) : config2;
++      const holder = { value: unparse ? unparse(config2) : config2 };
++      this.ctx.emit("loader/persist-config", entry, holder);
++      entry.options.config = holder.value;
+       entry.parent.tree.commit({ id: entry.options.id, group: entry.parent, options: entry.options, legacy });
+     });
+     ctx.on("internal/update", function(config2, next) {

package/patches/@cordisjs+plugin-server@1.7.0.patch

@@ -0,0 +1,22 @@
+diff --git a/lib/index.js b/lib/index.js
+index 4ff0ca1..4886ec6 100644
+--- a/lib/index.js
++++ b/lib/index.js
+@@ -210,7 +210,7 @@ var Route = class {
+     this.server = server;
+     this.path = path;
+     this.options = options;
+-    this.config = server[Server.resolveConfig]();
++    this.config = server[Server.resolveIntercept]();
+     this.fiber = server.ctx.fiber;
+     const paths = [path];
+     if (this.config.path) paths.unshift(this.config.path);
+@@ -462,7 +462,7 @@ var Server = class _Server extends Service2 {
+     yield () => this.ctx.logger?.info(`server closing at %C`, `http://${this.host}:${this.port}`);
+   }
+   get baseUrl() {
+-    const intercept = this[Service2.resolveConfig]();
++    const intercept = this[Service2.resolveIntercept]();
+     const pathPrefix = intercept.path ?? "";
+     if (this.config.baseUrl) return this.config.baseUrl + pathPrefix;
+     const wildcard = ["0.0.0.0", "::"];

package/patches/@cordisjs+unyaml@2.0.3.patch

@@ -0,0 +1,69 @@
+diff --git a/lib/vite.js b/lib/vite.js
+index b16d836..b1c6380 100644
+--- a/lib/vite.js
++++ b/lib/vite.js
+@@ -5,7 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+ var __getOwnPropNames = Object.getOwnPropertyNames;
+ var __getProtoOf = Object.getPrototypeOf;
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
+-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+ var __copyProps = (to, from, except, desc) => {
+   if (from && typeof from === "object" || typeof from === "function") {
+     for (let key of __getOwnPropNames(from))
+@@ -15,10 +14,6 @@ var __copyProps = (to, from, except, desc) => {
+   return to;
+ };
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+-  // If the importer is in node compatibility mode or this is not an ESM
+-  // file that has been converted to a CommonJS file using a Babel-
+-  // compatible transform (i.e. "__esModule" has not been set), then set
+-  // "default" to the CommonJS "module.exports" for node compatibility.
+   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+   mod
+ ));
+@@ -26,16 +21,36 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
+ // src/vite.ts
+ var yaml = __toESM(require("js-yaml"));
+ var import_tosource = __toESM(require("tosource"));
+-var import_esbuild = __toESM(require("./esbuild"));
+ function unyaml(options = {}) {
+   const { filter = /\.ya?ml(?:\?.*)?$/, ...loadOptions } = options;
+   return {
+     name: "unyaml",
+     config() {
++      // Vite dependency optimization uses Rolldown, not the retired esbuildOptions hook.
+       return {
+         optimizeDeps: {
+-          esbuildOptions: {
+-            plugins: [(0, import_esbuild.default)({ filter, ...loadOptions })]
++          rolldownOptions: {
++            plugins: [{
++              name: "unyaml",
++              async resolveId(id, importer) {
++                if (!filter.test(id)) return;
++                // The scanner resolves nothing itself: a relative id has to be joined to its importer, not the process cwd.
++                if (id.startsWith(".") && importer) {
++                  const path = require("node:path");
++                  return path.resolve(path.dirname(importer), id);
++                }
++                const resolved = await this.resolve(id, importer, { skipSelf: true });
++                return resolved?.id ?? id;
++              },
++              async load(id) {
++                if (!filter.test(id)) return;
++                const text = await import("node:fs/promises").then((m) => m.readFile(id, "utf8"));
++                const data = yaml.load(text, { ...loadOptions, filename: id });
++                return {
++                  code: `export default ${(0, import_tosource.default)(data)}`
++                };
++              }
++            }]
+           }
+         }
+       };
+@@ -50,5 +65,4 @@ function unyaml(options = {}) {
+     }
+   };
+ }
+-__name(unyaml, "unyaml");
+ module.exports = unyaml;