@seedcord/core 0.11.0 → 0.12.0-next.2

package/dist/{PluginHost-DB4j8unu.d.mts → PluginHost-DFnkIldj.d.mts}

@@ -1,8 +1,9 @@
-import { i as Bus, n as StartupPhase, r as CoreBase, t as ShutdownPhase } from "./phases-FTM69J3a.mjs";
+import { P as Kv, a as Bus, i as CoreBase, n as StartupPhase, r as TaskShutdownPhase } from "./phases-C2QCSqRu.mjs";
 import { Logger } from "@seedcord/logger";
 import { REST } from "@discordjs/rest";
 import { HostPluginKeys } from "@seedcord/types/internal";
 import { Config, FrameworkChannel, HmrAware, HmrUpdateEvent, IRateLimiter, Tail, TypedExclude } from "@seedcord/types";
+import { Promisable } from "type-fest";
 //#region src/plugin/brands.d.ts
 declare const TransportBrand: unique symbol;
 declare const RuntimeBrand: unique symbol;
@@ -35,7 +36,7 @@ interface PluginLifecycleSpec {
   };
   /** Defaults to `ShutdownPhase.Disconnect` and 10000ms. */
   dispose?: {
-    phase?: ShutdownPhase;
+    phase?: TaskShutdownPhase;
     timeout?: number;
   };
 }
@@ -49,7 +50,7 @@ interface ResolvedPluginLifecycleSpec {
     readonly timeout: number;
   };
   readonly dispose: {
-    readonly phase: ShutdownPhase;
+    readonly phase: TaskShutdownPhase;
     readonly timeout: number;
   };
 }
@@ -124,7 +125,7 @@ type RuntimeAssert<Plug, BotRt extends Runtime> = BrandRuntime<Plug> extends 'an
 //#endregion
 //#region src/plugin/Plugin.d.ts
 interface Initializeable {
-  init(): Promise<void>;
+  init(): Promisable<void>;
 }
 /** @internal */
 declare const resolvedSpecSlot: unique symbol;
@@ -138,7 +139,7 @@ declare const FixedScope: unique symbol;
  * Base class for a seedcord plugin. Extend it and implement `init()`. `this.core` is the running
  * bot.
  *
- * Your constructor takes the host first and passes it to `super()`. Add your own parameters after
+ * Take the host as your constructor's first parameter and pass it to `super()`. Add your own parameters after
  * it. `attach()` types them at the call site.
  *
  * A plugin that narrows `transport` or `runtime` in `Opts` passes the same values to `super()`.
@@ -167,6 +168,7 @@ declare const FixedScope: unique symbol;
  * ```
  */
 declare abstract class Plugin<Opts extends PluginOptions = {}, TCore extends CoreBase = CoreBase, Fixed extends ScopeAxis = never> implements Initializeable, HmrAware {
+  #private;
   private readonly host;
   /** @internal */
   protected static readonly [FixedScope]: Partial<DeclaredScope>;
@@ -185,18 +187,31 @@ declare abstract class Plugin<Opts extends PluginOptions = {}, TCore extends Cor
   constructor(host: CoreBase, ...[spec]: PluginSpecArgs<Opts, Fixed>);
   /** The host, typed to the transport whose `Plugin` base this class extends. */
   protected get core(): TCore;
+  /**
+   * This plugin's records in the bot's `config.kv`, stored under its attach key. Two attachments of
+   * one plugin class each get their own records. Renaming the attach key leaves the records under
+   * the old key behind.
+   *
+   * @throws A **SeedcordTypeError** when something built the plugin with `new` outside `attach()`.
+   * @example
+   * ```ts
+   * // works in a field initializer, the constructor, and every method
+   * private readonly jobs = this.kv.collection<Job>('job');
+   * ```
+   */
+  protected get kv(): Kv;
   /**
    * Runs in `StartupPhase.Configuration` by default.
    * Move it to a different phase with the {@link PluginLifecycleSpec}.
    */
-  abstract init(): Promise<void>;
+  abstract init(): Promisable<void>;
   /**
    * Runs in the Ready phase, after every attached plugin's `init()` has resolved. The other Ready
    * tasks run alongside it, including the http server binding its port.
    *
    * Override it when your work needs a logged-in client or a resolved application id.
    */
-  ready?(): Promise<void>;
+  ready?(): Promisable<void>;
   /**
    * Runs during teardown, in `ShutdownPhase.Disconnect` by default. seedcord skips it when `init()`
    * has thrown.
@@ -204,7 +219,16 @@ declare abstract class Plugin<Opts extends PluginOptions = {}, TCore extends Cor
    * When `init()` outlasts its timeout, seedcord calls this once that `init()` resolves, outside any
    * shutdown phase. The process must still be alive for that call to happen.
    */
-  dispose?(): Promise<void>;
+  dispose?(): Promisable<void>;
+  /**
+   * Returns data that `seedcord codegen` writes into the bot's `seedcord-gen.ts` as a type.
+   * Read it back with `Generated<typeof YourPlugin>`. Return plain data, or classes and objects
+   * that a project file or your plugin's package exports. The class needs a `static readonly id`.
+   *
+   * `seedcord codegen` calls this without running `init()`. Read only what the constructor stored
+   * and the bot's files.
+   */
+  codegen?(): Promise<unknown>;
   /**
    * Rejects the options this plugin got.
    *
@@ -213,7 +237,7 @@ declare abstract class Plugin<Opts extends PluginOptions = {}, TCore extends Cor
    */
   protected rejectOptions(reason: string): never;
   /** Override to reload plugin state on an HMR update. */
-  onHmr(_event: HmrUpdateEvent): Promise<void>;
+  onHmr(_event: HmrUpdateEvent): Promisable<void>;
   /**
    * Registers critical file patterns that should trigger a full restart when changed in Dev HMR.
    * @param patterns - Glob patterns. A relative one resolves against `root` from `seedcord.config.ts`.
@@ -254,9 +278,13 @@ declare abstract class PluginHost<BotT extends Transport, BotRt extends Runtime>
   abstract readonly config: Config;
   abstract readonly rest: REST;
   abstract readonly applicationId: string;
-  abstract readonly rateLimiter: IRateLimiter;
-  abstract readonly bus: Bus;
-  constructor(transport: BotT, runtime: BotRt);
+  /** @see {@link Bus} */
+  readonly bus: Bus;
+  /** @see {@link Kv} */
+  readonly kv: Kv;
+  /** @see {@link IRateLimiter} */
+  readonly rateLimiter: IRateLimiter;
+  constructor(transport: BotT, runtime: BotRt, driver: Config['kv']);
   /** @internal */
   get [attachmentsSlot](): readonly Attachment[];
   /** @internal */
@@ -274,7 +302,7 @@ declare abstract class PluginHost<BotT extends Transport, BotRt extends Runtime>
    * `start()`. An edge bot starts on its first request.
    *
    * Attaching a plugin whose `transport` or `runtime` differs from this host fails to compile.
-   * Your constructor takes `CoreBase` as its first parameter (you don't need to pass it though).
+   * Take `CoreBase` as your constructor's first parameter. `attach()` passes it, so you don't.
    * A narrower one fails to compile here.
    *
    * @param key - Also the channel the plugin logs on, dots included.
@@ -293,5 +321,5 @@ declare abstract class PluginHost<BotT extends Transport, BotRt extends Runtime>
 declare function attachmentsOf(host: Pick<PluginHost<Transport, Runtime>, typeof attachmentsSlot>): readonly Attachment[];
 declare function sealAttachments(host: Pick<PluginHost<Transport, Runtime>, typeof sealSlot>): void;
 //#endregion
-export { FixedScope as a, PluginArgs as c, Transport as d, PluginLifecycleSpec as f, sealAttachments as i, PluginCtor as l, PluginHost as n, Initializeable as o, attachmentsOf as r, Plugin as s, Attachment as t, PluginOptions as u };
-//# sourceMappingURL=PluginHost-DB4j8unu.d.mts.map
+export { FixedScope as a, PluginArgs as c, Runtime as d, Transport as f, sealAttachments as i, PluginCtor as l, PluginHost as n, Initializeable as o, PluginLifecycleSpec as p, attachmentsOf as r, Plugin as s, Attachment as t, PluginOptions as u };
+//# sourceMappingURL=PluginHost-DFnkIldj.d.mts.map

package/dist/PluginHost-DTtxWRiL.mjs

@@ -0,0 +1,552 @@
+import { b as StartupPhase, t as Bus, v as MemoryDriver, y as ShutdownPhase } from "./Bus-VJw-QpoY.mjs";
+import { SeedcordErrorCode, isSeedcordError } from "@seedcord/errors";
+import { SeedcordError, SeedcordRangeError, SeedcordTypeError } from "@seedcord/errors/internal";
+import { FRAMEWORK_CHANNELS, Logger } from "@seedcord/logger";
+import { HostPluginKeys } from "@seedcord/types/internal";
+
+//#region src/hmr/devChannel.ts
+let channel;
+/** @internal */
+function setDevChannel(next) {
+	channel = next;
+}
+/** @internal */
+function getDevChannel() {
+	return channel;
+}
+
+//#endregion
+//#region src/plugin/lifecycle.ts
+const DEFAULT_INIT_TIMEOUT_MS = 15e3;
+const DEFAULT_READY_TIMEOUT_MS = 15e3;
+const DEFAULT_DISPOSE_TIMEOUT_MS = 1e4;
+function timeoutOf(field, declared, fallback, pluginName) {
+	if (declared === void 0) return fallback;
+	if (!Number.isFinite(declared) || declared <= 0) throw new SeedcordRangeError(SeedcordErrorCode.LifecycleInvalidTimeout, [`${pluginName}'s lifecycle ${field}.timeout`, declared]);
+	return declared;
+}
+/** @internal */
+function resolveLifecycleSpec(spec, pluginName) {
+	return {
+		init: {
+			phase: spec?.init?.phase ?? 1,
+			timeout: timeoutOf("init", spec?.init?.timeout, DEFAULT_INIT_TIMEOUT_MS, pluginName)
+		},
+		ready: { timeout: timeoutOf("ready", spec?.ready?.timeout, DEFAULT_READY_TIMEOUT_MS, pluginName) },
+		dispose: {
+			phase: spec?.dispose?.phase ?? 3,
+			timeout: timeoutOf("dispose", spec?.dispose?.timeout, DEFAULT_DISPOSE_TIMEOUT_MS, pluginName)
+		}
+	};
+}
+
+//#endregion
+//#region src/plugin/Plugin.ts
+let attaching;
+/** @internal */
+const resolvedSpecSlot = Symbol("seedcord:plugin:spec");
+/** @internal */
+const loggerSlot = Symbol("seedcord:plugin:logger");
+/** @internal */
+const scopeSlot = Symbol("seedcord:plugin:scope");
+/** @internal */
+const FixedScope = Symbol("seedcord:plugin:fixed-scope");
+/**
+* Base class for a seedcord plugin. Extend it and implement `init()`. `this.core` is the running
+* bot.
+*
+* Take the host as your constructor's first parameter and pass it to `super()`. Add your own parameters after
+* it. `attach()` types them at the call site.
+*
+* A plugin that narrows `transport` or `runtime` in `Opts` passes the same values to `super()`.
+* `attach()` throws when either one differs from the bot's.
+*
+* @typeParam Opts - Where this plugin may attach.
+* @typeParam TCore - The `Core` each transport binds `this.core` to.
+* @typeParam Fixed - The `transport` and `runtime` values a transport's own `Plugin` base sets. Leave it out.
+*
+* @example
+* ```ts
+* class Analytics extends Plugin<{ transport: 'gateway' }> {
+*     constructor(
+*         host: CoreBase,
+*         private readonly apiKey: string
+*     ) {
+*         super(host, { transport: 'gateway', init: { phase: StartupPhase.Login } });
+*     }
+*
+*     public async init(): Promise<void> {
+*         await this.connect(this.apiKey);
+*     }
+* }
+*
+* seedcord.attach('analytics', Analytics, apiKey);
+* ```
+*/
+var Plugin = class {
+	host;
+	/** @internal */
+	static [FixedScope] = {};
+	/** @internal */
+	[resolvedSpecSlot];
+	/** @internal */
+	[loggerSlot];
+	/** @internal */
+	[scopeSlot];
+	/** Logs under the plugin's class name, on the channel its attach key sets. */
+	logger;
+	#kv;
+	constructor(host, ...[spec]) {
+		this.host = host;
+		const attachment = attaching;
+		attaching = void 0;
+		this.#kv = attachment?.kv;
+		this.logger = new Logger(this.constructor.name, attachment && { channel: attachment.key });
+		this[loggerSlot] = this.logger;
+		this[resolvedSpecSlot] = resolveLifecycleSpec(spec, this.constructor.name);
+		const passed = spec;
+		const fixed = new.target[FixedScope];
+		this[scopeSlot] = {
+			transport: fixed.transport ?? passed?.transport ?? "any",
+			runtime: fixed.runtime ?? passed?.runtime ?? "any"
+		};
+	}
+	/** The host, typed to the transport whose `Plugin` base this class extends. */
+	get core() {
+		return this.host;
+	}
+	/**
+	* This plugin's records in the bot's `config.kv`, stored under its attach key. Two attachments of
+	* one plugin class each get their own records. Renaming the attach key leaves the records under
+	* the old key behind.
+	*
+	* @throws A **SeedcordTypeError** when something built the plugin with `new` outside `attach()`.
+	* @example
+	* ```ts
+	* // works in a field initializer, the constructor, and every method
+	* private readonly jobs = this.kv.collection<Job>('job');
+	* ```
+	*/
+	get kv() {
+		if (!this.#kv) throw new SeedcordTypeError(SeedcordErrorCode.CorePluginKvOutsideAttach, [this.constructor.name]);
+		return this.#kv;
+	}
+	/**
+	* Rejects the options this plugin got.
+	*
+	* @param reason - Why the options are invalid.
+	* @throws A **SeedcordTypeError** every time, with the plugin class name and `reason` in its message.
+	*/
+	rejectOptions(reason) {
+		throw new SeedcordTypeError(SeedcordErrorCode.PluginOptionsRejected, [this.constructor.name, reason]);
+	}
+	/** Override to reload plugin state on an HMR update. */
+	onHmr(_event) {
+		return Promise.resolve();
+	}
+	/**
+	* Registers critical file patterns that should trigger a full restart when changed in Dev HMR.
+	* @param patterns - Glob patterns. A relative one resolves against `root` from `seedcord.config.ts`.
+	*/
+	registerCriticalFiles(patterns) {
+		getDevChannel()?.send("seedcord:register-critical-files", { patterns });
+	}
+};
+/** @internal */
+function resolvedLifecycleSpecOf(plugin) {
+	return plugin[resolvedSpecSlot];
+}
+/** @internal */
+function extendsThisCorePlugin(ctor) {
+	return ctor.prototype instanceof Plugin;
+}
+/** @internal */
+function pluginLoggerOf(plugin) {
+	return plugin[loggerSlot];
+}
+/** @internal */
+function declaredScopeOf(plugin) {
+	return plugin[scopeSlot];
+}
+/** @internal */
+function constructAttached(key, kv, construct) {
+	attaching = {
+		key,
+		kv
+	};
+	try {
+		return construct();
+	} finally {
+		attaching = void 0;
+	}
+}
+
+//#endregion
+//#region src/kv/GuardedDriver.ts
+function translated(operation, key, error) {
+	if (isSeedcordError(error)) return error;
+	return new SeedcordError(SeedcordErrorCode.CoreKvDriverFailed, [operation, key], { cause: error });
+}
+async function guard(operation, key, run) {
+	try {
+		return await run();
+	} catch (error) {
+		throw translated(operation, key, error);
+	}
+}
+var GuardedDriver = class {
+	driver;
+	constructor(driver) {
+		this.driver = driver;
+	}
+	async get(key) {
+		return guard("read", key, () => this.driver.get(key));
+	}
+	async set(key, value, ttlMs) {
+		await guard("write", key, () => this.driver.set(key, value, ttlMs));
+	}
+	async delete(key) {
+		await guard("delete", key, () => this.driver.delete(key));
+	}
+	async *entries(prefix) {
+		try {
+			for await (const entry of this.driver.entries(prefix)) yield entry;
+		} catch (error) {
+			throw translated("list", prefix, error);
+		}
+	}
+};
+
+//#endregion
+//#region src/kv/KeyedQueue.ts
+var KeyedQueue = class {
+	tails = /* @__PURE__ */ new Map();
+	run(key, task) {
+		const run = (this.tails.get(key) ?? Promise.resolve()).then(task);
+		const tail = run.then(() => void 0, () => void 0);
+		this.tails.set(key, tail);
+		tail.then(() => {
+			if (this.tails.get(key) === tail) this.tails.delete(key);
+		});
+		return run;
+	}
+};
+
+//#endregion
+//#region src/kv/KvCollection.ts
+/**
+* The records of one type, stored under one name in `config.kv`. Get one from
+* `kv.collection<T>('name')`.
+*
+* Every record goes through JSON on its way in and out. A `Date` you store reads back from `get()`
+* as an ISO string.
+*
+* @example
+* ```ts
+* interface Profile { bio: string; joinedAt: Date }
+* const profiles = this.core.kv.collection<Profile>('profile');
+*
+* await profiles.set(user.id, { bio: 'hi', joinedAt: new Date() });
+* const profile = await profiles.get(user.id); // { bio: string; joinedAt: string } | undefined
+* await profiles.delete(user.id);
+* ```
+*/
+var KvCollection = class {
+	#driver;
+	#prefix;
+	#updates;
+	constructor(driver, prefix, updates) {
+		this.#driver = driver;
+		this.#prefix = prefix;
+		this.#updates = updates;
+	}
+	/** Reads the record stored under `id`. Resolves to `undefined` when nothing is there or the record expired. */
+	async get(id) {
+		const key = this.#prefix + id;
+		const raw = await this.#driver.get(key);
+		const value = this.#liveValue(raw);
+		if (raw !== void 0 && value === void 0) await this.#deleteExpired(key);
+		return value;
+	}
+	/**
+	* Stores `value` under `id` and replaces whatever was there.
+	*
+	* @param ttlMs - How long the record lasts, in milliseconds. Leave it out to keep the record until you delete it.
+	*/
+	async set(id, value, ttlMs) {
+		const key = this.#prefix + id;
+		await this.#updates.run(key, async () => this.#write(key, value, ttlMs));
+	}
+	/** Removes the record under `id`. */
+	async delete(id) {
+		const key = this.#prefix + id;
+		await this.#updates.run(key, async () => this.#driver.delete(key));
+	}
+	/**
+	* Stores what `next` returns for the record under `id`, then resolves to that value. `next` gets
+	* the current record, or `undefined` when there is none.
+	*
+	* Use it over a `get()` then a `set()` when two calls can change one record at the same time.
+	* `set()`, `delete()`, and `update()` calls on one id run one after the other in this process.
+	* None of them loses another's change. Two processes sharing one backend can still both read
+	* before either writes.
+	*
+	* @param ttlMs - How many milliseconds the stored record lasts. Pass a function to work it out from the record. Leave it out to keep the record until you delete it.
+	* @example
+	* ```ts
+	* // counts a run of the command and resolves to the new count
+	* const runs = await counts.update(user.id, (count) => (count ?? 0) + 1);
+	* ```
+	*/
+	async update(id, next, ttlMs) {
+		const key = this.#prefix + id;
+		return this.#updates.run(key, async () => {
+			const value = next(this.#liveValue(await this.#driver.get(key)));
+			await this.#write(key, value, typeof ttlMs === "function" ? ttlMs(value) : ttlMs);
+			return value;
+		});
+	}
+	/**
+	* Yields `[id, record]` for every record in this collection that hasn't expired. Use it to read
+	* back what the bot saved before a restart.
+	*
+	* @throws A **SeedcordError** when the backend can't list its keys, like `@keyv/memcache`.
+	* @example
+	* ```ts
+	* // schedules every saved reminder again after a restart
+	* for await (const [id, reminder] of reminders.entries()) schedule(id, reminder);
+	* ```
+	*/
+	async *entries() {
+		const expired = [];
+		try {
+			for await (const [key, raw] of this.#driver.entries(this.#prefix)) {
+				const value = this.#liveValue(raw);
+				if (value === void 0) expired.push(key);
+				else yield [key.slice(this.#prefix.length), value];
+			}
+		} finally {
+			await Promise.all(expired.map(async (key) => this.#deleteExpired(key)));
+		}
+	}
+	async #write(key, value, ttlMs) {
+		const envelope = ttlMs === void 0 ? { value } : {
+			value,
+			expiresAt: Date.now() + ttlMs
+		};
+		await this.#driver.set(key, JSON.stringify(envelope), ttlMs);
+	}
+	async #deleteExpired(key) {
+		await this.#updates.run(key, async () => {
+			const raw = await this.#driver.get(key);
+			if (raw !== void 0 && this.#liveValue(raw) === void 0) await this.#driver.delete(key);
+		});
+	}
+	#liveValue(raw) {
+		if (raw === void 0) return void 0;
+		const envelope = JSON.parse(raw);
+		if (envelope.expiresAt !== void 0 && envelope.expiresAt <= Date.now()) return void 0;
+		return envelope.value;
+	}
+};
+
+//#endregion
+//#region src/kv/Kv.ts
+function keyPrefix(path) {
+	return path.map((segment) => `${encodeURIComponent(segment)}:`).join("");
+}
+/**
+* The bot's key-value store, or one prefixed slice of it. `core.kv` holds your handlers' records. A
+* plugin's `this.kv` holds the plugin's.
+*/
+var Kv = class {
+	/** What you passed as `config.kv`. Register its type in `KvTypes` to call the library's own methods on it. */
+	driver;
+	#guarded;
+	#path;
+	#updates = new KeyedQueue();
+	constructor(driver, ...path) {
+		this.driver = driver;
+		this.#guarded = new GuardedDriver(driver);
+		this.#path = path;
+	}
+	/**
+	* Records of one type under `name`. Pass the type argument. A record type holding a function,
+	* `Map`, `Set`, or `bigint` fails to compile here.
+	*/
+	collection(name) {
+		return new KvCollection(this.#guarded, keyPrefix([...this.#path, name]), this.#updates);
+	}
+};
+
+//#endregion
+//#region src/rateLimiter/KvRateLimiter.ts
+function limitedResult(live, now) {
+	const resetAt = live.reduce((earliest, exp) => Math.min(earliest, exp), Number.POSITIVE_INFINITY);
+	return {
+		limited: true,
+		resetAt,
+		remaining: 0,
+		retryAfterMs: resetAt - now
+	};
+}
+function openResult(remaining) {
+	return {
+		limited: false,
+		resetAt: 0,
+		remaining,
+		retryAfterMs: 0
+	};
+}
+function limitOf(window) {
+	return Math.max(1, window.limit ?? 1);
+}
+function liveUses(stored, now) {
+	return (stored ?? []).filter((exp) => exp > now);
+}
+var KvRateLimiter = class {
+	uses;
+	constructor(kv) {
+		this.uses = kv.collection("rate-limit");
+	}
+	async charge(key, window) {
+		const limit = limitOf(window);
+		let result;
+		await this.uses.update(key, (stored) => {
+			const now = Date.now();
+			const live = liveUses(stored, now);
+			const limited = live.length >= limit;
+			if (!limited) live.push(now + window.windowMs);
+			result = limited ? limitedResult(live, now) : openResult(limit - live.length);
+			return live;
+		}, (live) => live.reduce((latest, exp) => Math.max(latest, exp), 0) - Date.now());
+		return result;
+	}
+	async peek(key, window) {
+		const stored = await this.uses.get(key);
+		const now = Date.now();
+		const limit = limitOf(window);
+		const live = liveUses(stored, now);
+		return live.length >= limit ? limitedResult(live, now) : openResult(limit - live.length);
+	}
+	async reset(key) {
+		await this.uses.delete(key);
+	}
+};
+
+//#endregion
+//#region src/plugin/splitPluginKey.ts
+function splitPluginKey(key) {
+	const dot = key.indexOf(".");
+	return dot === -1 ? {
+		head: key,
+		leaf: void 0
+	} : {
+		head: key.slice(0, dot),
+		leaf: key.slice(dot + 1)
+	};
+}
+
+//#endregion
+//#region src/plugin/PluginHost.ts
+const RESERVED_KEYS = new Set(FRAMEWORK_CHANNELS);
+const attachmentsSlot = Symbol("seedcord:host:attachments");
+const sealSlot = Symbol("seedcord:host:seal");
+/** Base class for a plugin host. */
+var PluginHost = class {
+	/** @see {@link Bus} */
+	bus;
+	/** @see {@link Kv} */
+	kv;
+	/** @see {@link IRateLimiter} */
+	rateLimiter;
+	#sealed = false;
+	#attachments = [];
+	#groups = /* @__PURE__ */ new Map();
+	#scope;
+	constructor(transport, runtime, driver) {
+		this.#scope = {
+			transport,
+			runtime
+		};
+		this.bus = new Bus(this);
+		const kvDriver = driver ?? new MemoryDriver();
+		this.kv = new Kv(kvDriver, "app");
+		this.rateLimiter = new KvRateLimiter(new Kv(kvDriver, "seedcord"));
+	}
+	/** @internal */
+	get [attachmentsSlot]() {
+		return this.#attachments;
+	}
+	/** @internal */
+	[sealSlot]() {
+		this.#sealed = true;
+	}
+	/** @internal codegen reads this to emit the `Core` augmentation */
+	get [HostPluginKeys]() {
+		return this.#attachments.map((attachment) => attachment.key);
+	}
+	attach(key, Plugin, ...args) {
+		if (this.#sealed) throw new SeedcordError(SeedcordErrorCode.CorePluginAfterInit);
+		const { head, leaf } = splitPluginKey(key);
+		if (RESERVED_KEYS.has(head)) throw new SeedcordTypeError(SeedcordErrorCode.CorePluginReservedChannel, [head]);
+		if (head === "" || leaf === "") throw new SeedcordTypeError(SeedcordErrorCode.CorePluginKeyMalformed, [key, "has an empty part."]);
+		if (leaf?.includes(".")) throw new SeedcordTypeError(SeedcordErrorCode.CorePluginKeyMalformed, [key, "has more than one dot."]);
+		this.#assertFree(head, leaf, key);
+		if (!extendsThisCorePlugin(Plugin)) throw new SeedcordTypeError(SeedcordErrorCode.CorePluginFromOtherCore, [Plugin.name]);
+		const kv = new Kv(this.kv.driver, "plugins", key);
+		const instance = constructAttached(key, kv, () => new Plugin(this, ...args));
+		this.#assertScope(Plugin.name, declaredScopeOf(instance));
+		this.#attachments.push({
+			key,
+			instance,
+			spec: resolvedLifecycleSpecOf(instance)
+		});
+		if (leaf === void 0) return Object.assign(this, { [key]: instance });
+		this.#groupFor(head)[leaf] = instance;
+		return this;
+	}
+	#assertFree(head, leaf, key) {
+		if (leaf === void 0) {
+			if (this.#groups.has(key)) throw new SeedcordTypeError(SeedcordErrorCode.CorePluginKeyHoldsGroup, [key]);
+			if (key in this) throw new SeedcordTypeError(SeedcordErrorCode.CorePluginKeyExists, [key]);
+			return;
+		}
+		const group = this.#groups.get(head);
+		if (!group) {
+			if (head in this) throw new SeedcordTypeError(SeedcordErrorCode.CorePluginGroupTaken, [head, key]);
+			return;
+		}
+		if (Object.hasOwn(group, leaf)) throw new SeedcordTypeError(SeedcordErrorCode.CorePluginKeyExists, [key]);
+	}
+	#assertScope(pluginName, declared) {
+		for (const axis of ["transport", "runtime"]) {
+			const host = this.#scope[axis];
+			if (declared[axis] === "any" || declared[axis] === host) continue;
+			throw new SeedcordTypeError(SeedcordErrorCode.CorePluginScopeMismatch, [
+				pluginName,
+				axis,
+				declared[axis],
+				host
+			]);
+		}
+	}
+	#groupFor(head) {
+		const existing = this.#groups.get(head);
+		if (existing) return existing;
+		const group = Object.create(null);
+		this.#groups.set(head, group);
+		Object.assign(this, { [head]: group });
+		return group;
+	}
+};
+function attachmentsOf(host) {
+	return host[attachmentsSlot];
+}
+function sealAttachments(host) {
+	host[sealSlot]();
+}
+
+//#endregion
+export { KeyedQueue as a, pluginLoggerOf as c, splitPluginKey as i, getDevChannel as l, attachmentsOf as n, FixedScope as o, sealAttachments as r, Plugin as s, PluginHost as t, setDevChannel as u };
+//# sourceMappingURL=PluginHost-DTtxWRiL.mjs.map