@nomix-ai/nomix-harness 0.2.4 → 0.2.6

package/dist/kernel/cordis/lib/types/context.d.ts

@@ -0,0 +1,101 @@
+import type { Dict } from '../../../cosmokit/lib/index.js';
+import { EventsService } from './events.ts';
+import { LoggerService } from './logger.ts';
+import { ReflectService } from './reflect.ts';
+import { RegistryService, type InjectKey } from './registry.ts';
+import { symbols } from './utils.ts';
+import './fiber.ts';
+/**
+ * Public shape of a Cordis context.
+ *
+ * The concrete `Context` class is proxied at runtime, so this interface is
+ * augmented by core services and plugins to describe the properties that may
+ * be read from `ctx`.
+ */
+export interface Context {
+    /** Isolation map: service name → scope label. Lookups for a name resolve within its label. */
+    [symbols.isolate]: Dict<symbol>;
+    /** Intercept map: service name → config merged into that service's per-plugin config. */
+    [symbols.intercept]: Dict;
+    /** The root context of the application (every child context shares it). @experimental */
+    root: this;
+    /** Base URL used to resolve relative plugin/module specifiers, if the runtime sets one. */
+    baseUrl?: string;
+    /** The event bus. Its methods are also mixed onto `ctx` (`ctx.on`, `ctx.emit`, ...). */
+    events: EventsService;
+    /** The logging service. Call `ctx.logger(name)` for a named logger. */
+    logger: LoggerService;
+    /** The reflection layer backing the context proxy (`ctx.get`, `ctx.provide`, ...). */
+    reflect: ReflectService;
+    /** The plugin registry. Its methods are mixed onto `ctx` (`ctx.plugin`, `ctx.inject`). */
+    registry: RegistryService;
+}
+/**
+ * Root and child dependency containers for Cordis plugins.
+ *
+ * A context is a proxy: normal property reads go through the service resolver,
+ * while `extend()`, `isolate()`, and `intercept()` create scoped child
+ * contexts without mutating their parent.
+ */
+export declare class Context {
+    /** Symbol key under which a disposer exposes its {@link EffectMeta} diagnostics tree. */
+    static readonly effect: unique symbol;
+    /** Symbol key for a context's listener filter, consulted on every event dispatch. */
+    static readonly filter: unique symbol;
+    /** Symbol key of the isolation map (see the `Context[symbols.isolate]` property). */
+    static readonly isolate: unique symbol;
+    /** Symbol key of the intercept map (see the `Context[symbols.intercept]` property). */
+    static readonly intercept: unique symbol;
+    /**
+     * Returns true for Cordis context proxies and context prototypes.
+     *
+     * Works across realms and across multiple copies of cordis, because the
+     * brand is keyed by a global symbol rather than by `instanceof`.
+     *
+     * @param value — the value to test.
+     * @returns `true` if `value` is a Cordis context, narrowing its type.
+     */
+    static is(value: any): value is Context;
+    /** Create the root context and install the built-in services. */
+    constructor();
+    /**
+     * Create a child context with extra metadata on top of the current scope.
+     *
+     * The child prototypally inherits every property of this context; own
+     * properties of `meta` shadow the inherited ones. The parent is not mutated.
+     *
+     * @param meta — own properties (including symbol keys) to define on the child.
+     * @returns a child context inheriting from this one.
+     */
+    extend(meta?: {}): this;
+    /**
+     * Create a child context with an independent service scope for `name`.
+     *
+     * Below the returned context, reads and writes of the service `name`
+     * resolve against the new label instead of the parent's, so a different
+     * implementation can be provided without affecting the parent scope.
+     * Passing the same `label` to two `isolate()` calls joins their scopes.
+     *
+     * @param name — the service name to isolate.
+     * @param label — scope label to join; defaults to a fresh unique symbol.
+     * @returns a child context whose `name` service resolves in the new scope.
+     */
+    isolate(name: string, label?: symbol): this;
+    /**
+     * Add service-specific intercept config for plugins started below this
+     * context.
+     *
+     * Plugins loaded under the returned context see `config` merged into the
+     * service's resolved config (ancestor entries first; see
+     * `Service[symbols.resolveConfig]`). The parent context is not affected.
+     *
+     * @param name — the service name whose config to intercept.
+     * @param config — the intercept config to merge for that service.
+     * @returns a child context carrying the additional intercept entry.
+     */
+    intercept<K extends InjectKey>(name: K, config: Context[K] extends {
+        [symbols.config]: infer T;
+    } ? T : never): this;
+    intercept(name: string, config: any): this;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/kernel/cordis/lib/types/context.js

@@ -0,0 +1,99 @@
+import { EventsService } from "./events.js";
+import { LoggerService } from "./logger.js";
+import { ReflectService } from "./reflect.js";
+import { RegistryService } from "./registry.js";
+import { getTraceable, symbols } from "./utils.js";
+import { Fiber } from "./fiber.js";
+/**
+ * Root and child dependency containers for Cordis plugins.
+ *
+ * A context is a proxy: normal property reads go through the service resolver,
+ * while `extend()`, `isolate()`, and `intercept()` create scoped child
+ * contexts without mutating their parent.
+ */
+export class Context {
+    /** Symbol key under which a disposer exposes its {@link EffectMeta} diagnostics tree. */
+    static effect = symbols.effect;
+    /** Symbol key for a context's listener filter, consulted on every event dispatch. */
+    static filter = symbols.filter;
+    /** Symbol key of the isolation map (see the `Context[symbols.isolate]` property). */
+    static isolate = symbols.isolate;
+    /** Symbol key of the intercept map (see the `Context[symbols.intercept]` property). */
+    static intercept = symbols.intercept;
+    /**
+     * Returns true for Cordis context proxies and context prototypes.
+     *
+     * Works across realms and across multiple copies of cordis, because the
+     * brand is keyed by a global symbol rather than by `instanceof`.
+     *
+     * @param value — the value to test.
+     * @returns `true` if `value` is a Cordis context, narrowing its type.
+     */
+    static is(value) {
+        return !!value?.[Context.is];
+    }
+    static {
+        Context.is[Symbol.toPrimitive] = () => Symbol.for('cordis.is');
+        Context.prototype[Context.is] = true;
+    }
+    /** Create the root context and install the built-in services. */
+    constructor() {
+        this[symbols.isolate] = Object.create(null);
+        this[symbols.intercept] = Object.create(null);
+        const self = new Proxy(this, ReflectService.handler);
+        this.root = self;
+        this.baseUrl = undefined;
+        this.fiber = new Fiber(self, {}, Object.create(null), null, () => []);
+        this.reflect = new ReflectService(self);
+        this.registry = new RegistryService(self);
+        this.events = new EventsService(self);
+        this.logger = new LoggerService(self);
+        this.fiber._disposables.clear();
+        return self;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `Context <${this.fiber.name}>`;
+    }
+    /**
+     * Create a child context with extra metadata on top of the current scope.
+     *
+     * The child prototypally inherits every property of this context; own
+     * properties of `meta` shadow the inherited ones. The parent is not mutated.
+     *
+     * @param meta — own properties (including symbol keys) to define on the child.
+     * @returns a child context inheriting from this one.
+     */
+    extend(meta = {}) {
+        const shadow = Reflect.getOwnPropertyDescriptor(this, symbols.shadow)?.value;
+        const self = Object.create(getTraceable(this, this));
+        for (const prop of Reflect.ownKeys(meta)) {
+            Object.defineProperty(self, prop, Reflect.getOwnPropertyDescriptor(meta, prop));
+        }
+        if (!shadow)
+            return self;
+        return Object.assign(Object.create(self), { [symbols.shadow]: shadow });
+    }
+    /**
+     * Create a child context with an independent service scope for `name`.
+     *
+     * Below the returned context, reads and writes of the service `name`
+     * resolve against the new label instead of the parent's, so a different
+     * implementation can be provided without affecting the parent scope.
+     * Passing the same `label` to two `isolate()` calls joins their scopes.
+     *
+     * @param name — the service name to isolate.
+     * @param label — scope label to join; defaults to a fresh unique symbol.
+     * @returns a child context whose `name` service resolves in the new scope.
+     */
+    isolate(name, label) {
+        const shadow = Object.create(this[symbols.isolate]);
+        shadow[name] = label ?? Symbol(name);
+        return this.extend({ [symbols.isolate]: shadow });
+    }
+    intercept(name, config) {
+        const intercept = Object.create(this[symbols.intercept]);
+        intercept[name] = config;
+        return this.extend({ [symbols.intercept]: intercept });
+    }
+}
+//# sourceMappingURL=context.js.map

package/dist/kernel/cordis/lib/types/events.d.ts

@@ -0,0 +1,240 @@
+import type { Promisify } from '../../../cosmokit/lib/index.js';
+import { Context } from './context.ts';
+import { Fiber, FiberState } from './fiber.ts';
+/**
+ * Return whether an event result should stop a bail-style dispatch.
+ *
+ * @param value — a listener's return value.
+ * @returns `true` unless `value` is `null`, `false`, or `undefined`.
+ */
+export declare function isBailed(value: any): boolean;
+/** Extract the parameter tuple from a function type. */
+export type Parameters<F> = F extends (...args: infer P) => any ? P : never;
+/** Extract the return type from a function type. */
+export type ReturnType<F> = F extends (...args: any) => infer R ? R : never;
+/** Extract the explicit `this` type from a function type. */
+export type ThisType<F> = F extends (this: infer T, ...args: any) => any ? T : never;
+/**
+ * Event dispatch strategy used by the event service.
+ *
+ * `emit` runs synchronous listeners without awaiting them, `parallel` awaits
+ * all listeners together, `serial` awaits them in order until one bails,
+ * `bail` stops on the first synchronous bail value, and `waterfall` composes
+ * listeners around a final `next` callback.
+ */
+export type DispatchMode = 'emit' | 'parallel' | 'serial' | 'bail' | 'waterfall';
+declare module './context.ts' {
+    interface Context {
+        /**
+         * Dispatch an event, running all listeners concurrently.
+         *
+         * @param name — the event name.
+         * @param args — arguments passed to every listener.
+         * @returns a promise resolving once every listener has settled.
+         */
+        parallel<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): Promise<void>;
+        /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+        parallel<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): Promise<void>;
+        /**
+         * Dispatch an event synchronously, ignoring listener return values.
+         *
+         * @param name — the event name.
+         * @param args — arguments passed to every listener.
+         */
+        emit<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): void;
+        /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+        emit<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): void;
+        /**
+         * Dispatch an event, awaiting listeners in order until one bails.
+         *
+         * @param name — the event name.
+         * @param args — arguments passed to each listener.
+         * @returns the first bail value (non-null, non-false, non-undefined), if any.
+         */
+        serial<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): Promisify<ReturnType<Events[K]>>;
+        /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+        serial<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): Promisify<ReturnType<Events[K]>>;
+        /**
+         * Dispatch an event, calling listeners in order until one bails.
+         *
+         * @param name — the event name.
+         * @param args — arguments passed to each listener.
+         * @returns the first bail value (non-null, non-false, non-undefined), if any.
+         */
+        bail<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): ReturnType<Events[K]>;
+        /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+        bail<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): ReturnType<Events[K]>;
+        /**
+         * Dispatch an event whose last argument is a `next` continuation.
+         *
+         * Each listener wraps the rest of the chain: calling `next()` invokes the
+         * next listener (finally the built-in behavior); not calling it vetoes.
+         *
+         * @param name — the event name.
+         * @param args — listener arguments; the final one is the innermost `next`.
+         * @returns the outermost listener's return value.
+         */
+        waterfall<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): ReturnType<Events[K]>;
+        /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+        waterfall<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): ReturnType<Events[K]>;
+        /**
+         * Register an event listener owned by the current fiber.
+         *
+         * @param name — the event name to listen for.
+         * @param listener — called with the dispatch arguments.
+         * @param options — listener options; a boolean is shorthand for `prepend`.
+         * @returns a disposer removing the listener; `true` if it was still registered.
+         */
+        on<K extends keyof Events>(name: K, listener: Events[K], options?: boolean | EventOptions): () => boolean;
+        /**
+         * Same as `on()`, but the listener disposes itself after its first call.
+         *
+         * @param name — the event name to listen for.
+         * @param listener — called at most once with the dispatch arguments.
+         * @param options — listener options; a boolean is shorthand for `prepend`.
+         * @returns a disposer removing the listener; `true` if it was still registered.
+         */
+        once<K extends keyof Events>(name: K, listener: Events[K], options?: boolean | EventOptions): () => boolean;
+    }
+}
+/** Options accepted by `ctx.on()` and `ctx.once()`. */
+export interface EventOptions {
+    /** Add the listener before existing listeners for the same event. */
+    prepend?: boolean;
+    /** Receive the event regardless of context filter checks. */
+    global?: boolean;
+}
+/** Registered listener record stored by the event service. */
+export interface Hook extends EventOptions {
+    ctx: Context;
+    callback: (...args: any[]) => any;
+}
+/**
+ * Event bus installed as `ctx.events` and mixed into every context.
+ *
+ * The service supports concurrent, synchronous, serial, bail, and waterfall
+ * dispatch and automatically disposes listeners with their owning fiber.
+ */
+export declare class EventsService {
+    private ctx;
+    _hooks: Record<keyof any, Hook[]>;
+    constructor(ctx: Context);
+    /**
+     * Resolve listeners for one dispatch and apply context filtering.
+     *
+     * @param type — the dispatch mode, reported on `internal/dispatch`.
+     * @param args — the raw dispatch arguments; consumed up to the event name.
+     * @returns the matching listener callbacks, bound to the dispatch `this`.
+     */
+    dispatch(type: string, args: any[]): ((...args: any[]) => any)[];
+    /**
+     * Run listeners concurrently and wait for all of them.
+     *
+     * @param args — optional `this`, the event name, then listener arguments.
+     * @returns a promise resolving once every listener has settled.
+     */
+    parallel(...args: any[]): Promise<void>;
+    /**
+     * Run listeners synchronously without waiting for returned promises.
+     *
+     * @param args — optional `this`, the event name, then listener arguments.
+     */
+    emit(...args: any[]): void;
+    /**
+     * Run listeners in order, awaiting each, until one returns a bail value.
+     *
+     * @param args — optional `this`, the event name, then listener arguments.
+     * @returns the first bail value (see {@link isBailed}), if any.
+     */
+    serial(...args: any[]): Promise<any>;
+    /**
+     * Run listeners synchronously until one returns a bail value.
+     *
+     * @param args — optional `this`, the event name, then listener arguments.
+     * @returns the first bail value (see {@link isBailed}), if any.
+     */
+    bail(...args: any[]): any;
+    /**
+     * Compose listeners around the final `next` callback.
+     *
+     * The last dispatch argument is treated as the innermost `next`. Listeners
+     * run outermost-first; a listener that does not call `next()` vetoes the
+     * rest of the chain, including the built-in behavior.
+     *
+     * @param args — optional `this`, the event name, listener arguments, then `next`.
+     * @returns the outermost listener's return value.
+     */
+    waterfall(...args: any[]): any;
+    /**
+     * Store a listener record as an effect on the current fiber.
+     *
+     * @param label — effect label shown in fiber diagnostics.
+     * @param hooks — the listener list for one event.
+     * @param callback — the listener to store.
+     * @param options — placement and filtering options.
+     * @returns a disposer that unregisters the listener.
+     */
+    register(label: string, hooks: Hook[], callback: any, options: EventOptions): () => void;
+    /**
+     * Remove a stored listener record.
+     *
+     * @param hooks — the listener list for one event.
+     * @param callback — the listener to remove.
+     * @returns `true` if the listener was found and removed.
+     */
+    unregister(hooks: Hook[], callback: any): true | undefined;
+    /**
+     * Register an event listener owned by the current fiber.
+     *
+     * The listener is removed automatically when the fiber unloads. Throws
+     * `CordisError('INACTIVE_EFFECT')` if the fiber is already disposed.
+     *
+     * @param name — the event name to listen for.
+     * @param listener — called with the dispatch arguments.
+     * @param options — listener options; a boolean is shorthand for `prepend`.
+     * @returns a disposer removing the listener; `true` if it was still registered.
+     */
+    on(name: string | symbol, listener: (...args: any) => any, options?: boolean | EventOptions): any;
+    /**
+     * Register an event listener that disposes itself after the first call.
+     *
+     * @param name — the event name to listen for.
+     * @param listener — called at most once with the dispatch arguments.
+     * @param options — listener options; a boolean is shorthand for `prepend`.
+     * @returns a disposer removing the listener; `true` if it was still registered.
+     */
+    once(name: string, listener: (...args: any) => any, options?: boolean | EventOptions): any;
+}
+/**
+ * Built-in framework events used by core services and extension points.
+ *
+ * Plugin and status events track fiber lifecycle, service events observe
+ * dependency registration, update/get/set/listener events allow core services
+ * to intercept runtime operations, and `internal/dispatch` exposes event-bus
+ * diagnostics before public events are delivered.
+ */
+export interface Events {
+    /** A plugin fiber was created or its uid was cleared on disposal. */
+    'internal/plugin'(fiber: Fiber): void;
+    /** A fiber changed lifecycle state; receives the fiber and its previous state. */
+    'internal/status'(fiber: Fiber, oldValue: FiberState): void;
+    /**
+     * Resolve raw plugin config after the fiber's injections become active.
+     * @param config - the raw config for this activation.
+     * @mode waterfall
+     */
+    'internal/config'(this: Fiber, config: any, next: () => any): any;
+    /** Interception hook for a service binding (no core producer). */
+    'internal/service'(this: Context, name: string, value: any): void;
+    /** Waterfall: a fiber config update is being applied; skip `next()` to veto. */
+    'internal/update'(this: Fiber, config: any, noSave: boolean, next: () => void | Promise<void>): void | Promise<void>;
+    /** Waterfall: a service is being read through the context proxy. */
+    'internal/get'(ctx: Context, name: string, error: Error, next: () => any): any;
+    /** Waterfall: a service is being written through the context proxy. */
+    'internal/set'(ctx: Context, name: string, value: any, error: Error, next: () => boolean): boolean;
+    /** Bail: a listener is being registered; a non-null result replaces registration. */
+    'internal/listener'(this: Context, name: string, listener: any, prepend: boolean): void;
+    /** An event is being dispatched to listeners (fired for non-internal events only). */
+    'internal/dispatch'(mode: DispatchMode, name: string, args: any[], thisArg: any): void;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/kernel/cordis/lib/types/events.js

@@ -0,0 +1,199 @@
+import { defineProperty } from '../../../cosmokit/lib/index.js';
+import { Context } from "./context.js";
+import { DisposableList, symbols } from "./utils.js";
+/**
+ * Return whether an event result should stop a bail-style dispatch.
+ *
+ * @param value — a listener's return value.
+ * @returns `true` unless `value` is `null`, `false`, or `undefined`.
+ */
+export function isBailed(value) {
+    return value !== null && value !== false && value !== undefined;
+}
+/**
+ * Event bus installed as `ctx.events` and mixed into every context.
+ *
+ * The service supports concurrent, synchronous, serial, bail, and waterfall
+ * dispatch and automatically disposes listeners with their owning fiber.
+ */
+export class EventsService {
+    ctx;
+    _hooks = {};
+    constructor(ctx) {
+        this.ctx = ctx;
+        defineProperty(this, symbols.tracker, {
+            property: 'ctx',
+            noShadow: true,
+        });
+        this.on('internal/listener', function (name, listener, options) {
+            if (name === 'internal/update' && !options.global) {
+                const hooks = this.fiber._hooks['internal/update'] ??= new DisposableList();
+                const method = options.prepend ? 'unshift' : 'push';
+                return hooks[method](listener);
+            }
+        });
+        this.on('internal/update', function (config, noSave, next) {
+            const cbs = [...this._hooks['internal/update'] || []];
+            const _next = () => {
+                const cb = cbs.shift() ?? next;
+                return cb.call(this, config, noSave, _next);
+            };
+            return _next();
+        }, { global: true, prepend: true });
+    }
+    /**
+     * Resolve listeners for one dispatch and apply context filtering.
+     *
+     * @param type — the dispatch mode, reported on `internal/dispatch`.
+     * @param args — the raw dispatch arguments; consumed up to the event name.
+     * @returns the matching listener callbacks, bound to the dispatch `this`.
+     */
+    dispatch(type, args) {
+        const thisArg = typeof args[0] === 'object' || typeof args[0] === 'function' ? args.shift() : null;
+        const name = args.shift();
+        if (!name.startsWith('internal/')) {
+            this.emit('internal/dispatch', type, name, args, thisArg);
+        }
+        const filter = thisArg?.[Context.filter];
+        return (this._hooks[name] || [])
+            .filter(hook => hook.global || !filter || filter.call(thisArg, hook.ctx))
+            .map(hook => hook.callback.bind(thisArg));
+    }
+    /**
+     * Run listeners concurrently and wait for all of them.
+     *
+     * @param args — optional `this`, the event name, then listener arguments.
+     * @returns a promise resolving once every listener has settled.
+     */
+    async parallel(...args) {
+        const results = await Promise.allSettled(this.dispatch('emit', args).map(async (cb) => cb(...args)));
+        const errors = results.filter((result) => result.status === 'rejected');
+        if (errors.length)
+            throw new AggregateError(errors.map(error => error.reason));
+    }
+    /**
+     * Run listeners synchronously without waiting for returned promises.
+     *
+     * @param args — optional `this`, the event name, then listener arguments.
+     */
+    emit(...args) {
+        this.dispatch('emit', args).map(cb => cb(...args));
+    }
+    /**
+     * Run listeners in order, awaiting each, until one returns a bail value.
+     *
+     * @param args — optional `this`, the event name, then listener arguments.
+     * @returns the first bail value (see {@link isBailed}), if any.
+     */
+    async serial(...args) {
+        for (const cb of this.dispatch('serial', args)) {
+            const result = await cb(...args);
+            if (isBailed(result))
+                return result;
+        }
+    }
+    /**
+     * Run listeners synchronously until one returns a bail value.
+     *
+     * @param args — optional `this`, the event name, then listener arguments.
+     * @returns the first bail value (see {@link isBailed}), if any.
+     */
+    bail(...args) {
+        for (const cb of this.dispatch('bail', args)) {
+            const result = cb(...args);
+            if (isBailed(result))
+                return result;
+        }
+    }
+    /**
+     * Compose listeners around the final `next` callback.
+     *
+     * The last dispatch argument is treated as the innermost `next`. Listeners
+     * run outermost-first; a listener that does not call `next()` vetoes the
+     * rest of the chain, including the built-in behavior.
+     *
+     * @param args — optional `this`, the event name, listener arguments, then `next`.
+     * @returns the outermost listener's return value.
+     */
+    waterfall(...args) {
+        const cbs = this.dispatch('waterfall', args);
+        const inner = args.pop();
+        const next = () => {
+            const cb = cbs.shift() ?? inner;
+            return cb(...args);
+        };
+        args.push(next);
+        return next();
+    }
+    /**
+     * Store a listener record as an effect on the current fiber.
+     *
+     * @param label — effect label shown in fiber diagnostics.
+     * @param hooks — the listener list for one event.
+     * @param callback — the listener to store.
+     * @param options — placement and filtering options.
+     * @returns a disposer that unregisters the listener.
+     */
+    register(label, hooks, callback, options) {
+        const method = options.prepend ? 'unshift' : 'push';
+        return this.ctx.fiber.effect(() => {
+            hooks[method]({ ctx: this.ctx, callback, ...options });
+            return () => this.unregister(hooks, callback);
+        }, label);
+    }
+    /**
+     * Remove a stored listener record.
+     *
+     * @param hooks — the listener list for one event.
+     * @param callback — the listener to remove.
+     * @returns `true` if the listener was found and removed.
+     */
+    unregister(hooks, callback) {
+        const index = hooks.findIndex(hook => hook.callback === callback);
+        if (index >= 0) {
+            hooks.splice(index, 1);
+            return true;
+        }
+    }
+    /**
+     * Register an event listener owned by the current fiber.
+     *
+     * The listener is removed automatically when the fiber unloads. Throws
+     * `CordisError('INACTIVE_EFFECT')` if the fiber is already disposed.
+     *
+     * @param name — the event name to listen for.
+     * @param listener — called with the dispatch arguments.
+     * @param options — listener options; a boolean is shorthand for `prepend`.
+     * @returns a disposer removing the listener; `true` if it was still registered.
+     */
+    on(name, listener, options) {
+        if (typeof options !== 'object') {
+            options = { prepend: options };
+        }
+        // handle special events
+        this.ctx.fiber.assertActive();
+        listener = this.ctx.reflect.bind(listener);
+        const result = this.bail(this.ctx, 'internal/listener', name, listener, options);
+        if (result)
+            return result;
+        const hooks = this._hooks[name] ||= [];
+        const label = `ctx.on(${typeof name === 'string' ? JSON.stringify(name) : name.toString()})`;
+        return this.register(label, hooks, listener, options);
+    }
+    /**
+     * Register an event listener that disposes itself after the first call.
+     *
+     * @param name — the event name to listen for.
+     * @param listener — called at most once with the dispatch arguments.
+     * @param options — listener options; a boolean is shorthand for `prepend`.
+     * @returns a disposer removing the listener; `true` if it was still registered.
+     */
+    once(name, listener, options) {
+        const dispose = this.on(name, function (...args) {
+            dispose();
+            return listener.apply(this, args);
+        }, options);
+        return dispose;
+    }
+}
+//# sourceMappingURL=events.js.map