@nomix-ai/nomix-harness 0.2.4 → 0.2.5

package/dist/kernel/cordis-plugin-loader/lib/types/config/entry.d.ts

@@ -0,0 +1,56 @@
+import { Context, Fiber, Inject } from '../../../../cordis/lib/index.js';
+import { Loader } from '../index.ts';
+import { EntryGroup } from './group.ts';
+import { EntryTree } from './tree.ts';
+/** Serialized plugin entry options stored in loader config files. */
+export interface EntryOptions {
+    /** Stable id inside the containing entry tree. */
+    id: string;
+    /** Module specifier imported by the entry tree. */
+    name: string;
+    /** Config passed to the plugin. */
+    config?: any;
+    /** Marks this entry as a nested group. */
+    group?: boolean | null;
+    /** Prevents this entry and descendants from running. */
+    disabled?: boolean | null;
+    /** Required services or service intercept config for this entry. */
+    inject?: Inject | null;
+}
+/** One configured plugin node inside an `EntryTree`. */
+export declare class Entry {
+    loader: Loader;
+    static readonly key: unique symbol;
+    ctx: Context;
+    fiber?: Fiber;
+    parent: EntryGroup;
+    options: EntryOptions;
+    subgroup?: EntryGroup;
+    subtree?: EntryTree;
+    _initTask?: Promise<void>;
+    _disposing: number;
+    constructor(loader: Loader);
+    get context(): Context;
+    get id(): string;
+    /** True when this entry or any owning parent entry is disabled. */
+    get disabled(): boolean;
+    private _disabled;
+    /**
+     * Effective disabled state: a `!!js` expression evaluates against the loader
+     * context. The raw node stays in the options, so write-back keeps the form.
+     */
+    private disabledOf;
+    evaluate(expr: string): any;
+    private _patchContext;
+    refresh(): Promise<void>;
+    _dispose(fiber?: Fiber | undefined): Promise<void>;
+    /** Merge new options, restart as needed, and persist through the parent tree. */
+    update(options: Partial<EntryOptions>, create?: boolean, force?: boolean): Promise<void>;
+    getOuterStack: () => string[];
+    /** Import and start the configured plugin if it is not already running. */
+    init(): Promise<void>;
+    _await(): Promise<void>;
+    private _init;
+    private _start;
+}
+//# sourceMappingURL=entry.d.ts.map

package/dist/kernel/cordis-plugin-loader/lib/types/config/entry.js

@@ -0,0 +1,283 @@
+import { deepEqual, isNullable } from '../../../../cosmokit/lib/index.js';
+import { EntryTree } from "./tree.js";
+import { evaluate, isJsExpr } from "./utils.js";
+function updateError(stage, options, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    return new Error(`failed to ${stage} loader entry ${options.id} (${options.name}): ${detail}`, { cause });
+}
+function takeEntries(object, keys) {
+    const result = [];
+    for (const key of keys) {
+        if (!(key in object))
+            continue;
+        result.push([key, object[key]]);
+        delete object[key];
+    }
+    return result;
+}
+function sortKeys(object, prepend = ['id', 'name'], append = ['config']) {
+    const part1 = takeEntries(object, prepend);
+    const part2 = takeEntries(object, append);
+    const rest = takeEntries(object, Object.keys(object)).sort(([a], [b]) => a.localeCompare(b));
+    return Object.assign(object, Object.fromEntries([...part1, ...rest, ...part2]));
+}
+function replaceKeys(target, source) {
+    for (const key of Object.keys(target))
+        Reflect.deleteProperty(target, key);
+    return Object.assign(target, source);
+}
+/** One configured plugin node inside an `EntryTree`. */
+export class Entry {
+    loader;
+    static key = Symbol.for('cordis.entry');
+    ctx;
+    fiber;
+    parent;
+    // safety: call `entry.update()` immediately after creating an entry
+    options = {};
+    subgroup;
+    subtree;
+    _initTask;
+    _disposing = 0;
+    constructor(loader) {
+        this.loader = loader;
+        this.ctx = loader.ctx.extend({ [Entry.key]: this });
+        this.context.emit('loader/entry-init', this);
+    }
+    get context() {
+        return this.ctx;
+    }
+    get id() {
+        let id = this.options.id;
+        if (this.parent.tree.ctx.fiber.entry) {
+            id = this.parent.tree.ctx.fiber.entry.id + EntryTree.sep + id;
+        }
+        return id;
+    }
+    /** True when this entry or any owning parent entry is disabled. */
+    get disabled() {
+        return this._disabled(this.options);
+    }
+    _disabled(options) {
+        // group is always enabled
+        if (options.group)
+            return false;
+        if (this.disabledOf(options))
+            return true;
+        let entry = this.parent.ctx.fiber.entry;
+        while (entry) {
+            if (this.disabledOf(entry.options))
+                return true;
+            entry = entry.parent.ctx.fiber.entry;
+        }
+        return false;
+    }
+    /**
+     * Effective disabled state: a `!!js` expression evaluates against the loader
+     * context. The raw node stays in the options, so write-back keeps the form.
+     */
+    disabledOf(options) {
+        return isJsExpr(options.disabled)
+            ? Boolean(this.evaluate(options.disabled.__jsExpr))
+            : Boolean(options.disabled);
+    }
+    evaluate(expr) {
+        return evaluate(this.ctx, expr);
+    }
+    async _patchContext(diff) {
+        await this.context.waterfall('loader/patch-context', this, async () => {
+            Object.setPrototypeOf(this.ctx, this.parent.ctx);
+            if (this.fiber?.uid && (diff.includes('config') || this.options.group)) {
+                await this.fiber.update(this.options.config, true);
+            }
+        });
+    }
+    async refresh() {
+        if (this.fiber)
+            return;
+        if (this.disabled)
+            return;
+        await this.init();
+    }
+    async _dispose(fiber = this.fiber) {
+        if (!fiber)
+            return;
+        if (this.fiber === fiber)
+            this.fiber = undefined;
+        this._disposing += 1;
+        try {
+            await fiber.dispose();
+        }
+        finally {
+            this._disposing -= 1;
+        }
+    }
+    /** Merge new options, restart as needed, and persist through the parent tree. */
+    async update(options, create = false, force = false) {
+        const previousOptions = this.options;
+        const legacy = { ...previousOptions };
+        const candidate = create ? options : { ...previousOptions };
+        if (!create) {
+            for (const [key, value] of Object.entries(options)) {
+                if (isNullable(value)) {
+                    delete candidate[key];
+                }
+                else {
+                    candidate[key] = value;
+                }
+            }
+        }
+        sortKeys(candidate);
+        const diff = Object
+            .keys({ ...candidate, ...legacy })
+            .filter(key => !deepEqual(candidate[key], legacy[key]));
+        if (!diff.length && !force)
+            return;
+        const commit = () => {
+            if (create)
+                return;
+            this.options = replaceKeys(previousOptions, candidate);
+        };
+        const previous = this.fiber;
+        if (!previous?.uid) {
+            this.fiber = undefined;
+            this.options = candidate;
+            try {
+                if (!this._disabled(candidate))
+                    await this.init();
+            }
+            catch (error) {
+                this.options = previousOptions;
+                throw error;
+            }
+            commit();
+            return;
+        }
+        if (this._disabled(candidate)) {
+            this.options = candidate;
+            try {
+                await this._dispose(previous);
+            }
+            catch (error) {
+                this.options = previousOptions;
+                throw updateError('dispose', candidate, error);
+            }
+            commit();
+            this.context.emit('loader/partial-dispose', this, legacy, true);
+            return;
+        }
+        const replace = diff.some(key => key === 'name' || key === 'inject' || key === 'group');
+        if (!replace) {
+            this.options = candidate;
+            try {
+                await this._patchContext(diff);
+            }
+            catch (error) {
+                this.options = previousOptions;
+                try {
+                    await this._patchContext(diff);
+                }
+                catch (rollbackError) {
+                    throw updateError('rollback', legacy, new AggregateError([error, rollbackError]));
+                }
+                this.context.emit('loader/partial-dispose', this, candidate, true);
+                throw updateError('apply', candidate, error);
+            }
+            commit();
+            this.context.emit('loader/partial-dispose', this, legacy, true);
+            return;
+        }
+        let plugin;
+        try {
+            plugin = diff.includes('name')
+                ? this.loader.unwrapExports(await this.parent.tree.import(candidate.name, this.getOuterStack))
+                : previous.runtime.callback;
+        }
+        catch (error) {
+            throw updateError('import', candidate, error);
+        }
+        const previousPlugin = previous.runtime.callback;
+        this.options = candidate;
+        try {
+            await this._dispose(previous);
+        }
+        catch (error) {
+            this.options = previousOptions;
+            throw updateError('dispose', candidate, error);
+        }
+        try {
+            await this._start(plugin);
+        }
+        catch (error) {
+            this.options = previousOptions;
+            try {
+                await this._start(previousPlugin);
+            }
+            catch (rollbackError) {
+                throw updateError('rollback', legacy, new AggregateError([error, rollbackError]));
+            }
+            this.context.emit('loader/partial-dispose', this, candidate, true);
+            throw updateError('apply', candidate, error);
+        }
+        commit();
+        this.context.emit('loader/partial-dispose', this, legacy, true);
+    }
+    getOuterStack = () => {
+        let entry = this;
+        const result = [];
+        do {
+            result.push(`    at ${entry.parent.tree.ctx.baseUrl}#${entry.options.id}`);
+            entry = entry.parent.ctx.fiber.entry;
+        } while (entry);
+        return result;
+    };
+    /** Import and start the configured plugin if it is not already running. */
+    async init() {
+        try {
+            await (this._initTask ??= this._init());
+        }
+        finally {
+            this._initTask = undefined;
+            if (!this.loader.getTasks().length)
+                this.ctx.reflect.notify(['loader']);
+        }
+        await this._await();
+    }
+    async _await() {
+        try {
+            await this.fiber?.await();
+        }
+        catch (error) {
+            throw updateError('apply', this.options, error);
+        }
+    }
+    async _init() {
+        let plugin;
+        try {
+            plugin = this.loader.unwrapExports(await this.parent.tree.import(this.options.name, this.getOuterStack));
+        }
+        catch (error) {
+            throw updateError('import', this.options, error);
+        }
+        try {
+            await this._start(plugin);
+        }
+        catch (error) {
+            throw updateError('apply', this.options, error);
+        }
+    }
+    async _start(plugin) {
+        let fiber;
+        try {
+            await this._patchContext([]);
+            this.loader.showLog(this, 'apply');
+            fiber = this.fiber = this.ctx.registry.plugin(plugin, this.options.config, this.getOuterStack);
+            await fiber.await();
+        }
+        catch (error) {
+            await this._dispose(fiber);
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=entry.js.map

package/dist/kernel/cordis-plugin-loader/lib/types/config/group.d.ts

@@ -0,0 +1,27 @@
+import { Context, Service } from '../../../../cordis/lib/index.js';
+import { type EntryOptions } from './entry.ts';
+import { EntryTree } from './tree.ts';
+/** Runtime owner for a list of child loader entries. */
+export declare class EntryGroup {
+    ctx: Context;
+    tree: EntryTree;
+    static readonly key: unique symbol;
+    data: EntryOptions[];
+    constructor(ctx: Context, tree: EntryTree);
+    get context(): Context;
+    create(options: Omit<EntryOptions, 'id'>): Promise<string>;
+    unlink(options: EntryOptions): void;
+    remove(id: string, isDispose?: boolean): Promise<void>;
+    update(config: EntryOptions[]): Promise<void>;
+    stop(): Promise<void>;
+}
+/** Plugin that mounts a nested loader entry group. */
+export declare class Group extends EntryGroup {
+    ctx: Context;
+    config: EntryOptions[];
+    static initial: Omit<EntryOptions, 'id'>[];
+    static readonly [EntryGroup.key] = true;
+    constructor(ctx: Context, config: EntryOptions[]);
+    [Service.init](): AsyncGenerator<() => Promise<void>, void, unknown>;
+}
+//# sourceMappingURL=group.d.ts.map

package/dist/kernel/cordis-plugin-loader/lib/types/config/group.js

@@ -0,0 +1,139 @@
+import { Service } from '../../../../cordis/lib/index.js';
+import { Entry } from "./entry.js";
+/** Runtime owner for a list of child loader entries. */
+export class EntryGroup {
+    ctx;
+    tree;
+    static key = Symbol.for('cordis.group');
+    data = [];
+    constructor(ctx, tree) {
+        this.ctx = ctx;
+        this.tree = tree;
+        const entry = ctx.fiber.entry;
+        if (entry)
+            entry.subgroup = this;
+    }
+    get context() {
+        return this.ctx;
+    }
+    async create(options) {
+        const id = this.tree.ensureId(options);
+        const existing = this.tree.store[id];
+        const entry = existing ?? (this.tree.store[id] = new Entry(this.ctx.loader));
+        const previousParent = entry.parent;
+        // Entry may be moved from another group,
+        // so we need to update the parent reference.
+        entry.parent = this;
+        // Use `create: true` to replace existing entry.options.
+        try {
+            await entry.update(options, true, true);
+        }
+        catch (error) {
+            if (existing) {
+                entry.parent = previousParent;
+            }
+            else {
+                delete this.tree.store[id];
+            }
+            throw error;
+        }
+        return entry.id;
+    }
+    unlink(options) {
+        const config = this.data;
+        const index = config.indexOf(options);
+        if (index >= 0)
+            config.splice(index, 1);
+    }
+    async remove(id, isDispose = false) {
+        const entry = this.tree.store[id];
+        if (!entry)
+            return;
+        await entry._dispose();
+        if (!isDispose) {
+            this.unlink(entry.options);
+        }
+        delete this.tree.store[id];
+        this.context.emit('loader/partial-dispose', entry, entry.options, false);
+    }
+    async update(config) {
+        const oldConfig = this.data;
+        const seen = new Set();
+        for (const options of config) {
+            const id = this.tree.ensureId(options);
+            if (seen.has(id))
+                throw new TypeError(`duplicate loader entry id: ${id}`);
+            seen.add(id);
+        }
+        const oldMap = Object.fromEntries(oldConfig.map(options => [options.id, options]));
+        const newMap = Object.fromEntries(config.map(options => [options.id, options]));
+        try {
+            const outcomes = await Promise.allSettled(config.map(options => this.create(options)));
+            // Disposal owns termination: sibling starts can still be settling after
+            // the containing tree has gone away, but their failures no longer
+            // describe a live update to roll back.
+            if (this.ctx.fiber.uid === null)
+                return;
+            const failures = outcomes
+                .filter((outcome) => outcome.status === 'rejected')
+                .map(outcome => outcome.reason);
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, 'loader entries failed to apply');
+            for (const id of Object.keys(oldMap)) {
+                if (!newMap[id])
+                    await this.remove(id, true);
+            }
+            this.data = config;
+        }
+        catch (error) {
+            const rollbackErrors = [];
+            for (const id of Object.keys(newMap).reverse()) {
+                if (oldMap[id])
+                    continue;
+                try {
+                    await this.remove(id, true);
+                }
+                catch (rollbackError) {
+                    rollbackErrors.push(rollbackError);
+                }
+            }
+            for (const options of oldConfig) {
+                try {
+                    await this.create(options);
+                }
+                catch (rollbackError) {
+                    rollbackErrors.push(rollbackError);
+                }
+            }
+            this.data = oldConfig;
+            if (rollbackErrors.length)
+                throw new AggregateError([error, ...rollbackErrors], 'loader entry rollback failed');
+            throw error;
+        }
+    }
+    async stop() {
+        for (const options of this.data) {
+            await this.remove(options.id, true);
+        }
+    }
+}
+/** Plugin that mounts a nested loader entry group. */
+export class Group extends EntryGroup {
+    ctx;
+    config;
+    static initial = [];
+    static [EntryGroup.key] = true;
+    constructor(ctx, config) {
+        super(ctx, ctx.fiber.entry.parent.tree);
+        this.ctx = ctx;
+        this.config = config;
+        ctx.on('internal/update', config => this.update(config));
+    }
+    async *[Service.init]() {
+        yield () => this.stop();
+        await this.update(this.config);
+    }
+}
+//# sourceMappingURL=group.js.map

package/dist/kernel/cordis-plugin-loader/lib/types/config/isolate.d.ts

@@ -0,0 +1,35 @@
+import { Context } from '../../../../cordis/lib/index.js';
+import type { Dict } from '../../../../cosmokit/lib/index.js';
+import { Entry } from './entry.ts';
+declare module './entry.ts' {
+    interface EntryOptions {
+        intercept?: Dict | null;
+        isolate?: Dict<true | string> | null;
+    }
+    interface Entry {
+        realm: LocalRealm;
+    }
+}
+/** Symbol realm used to isolate service implementations by entry or label. */
+export declare abstract class Realm {
+    protected store: Dict<symbol>;
+    abstract get suffix(): string;
+    access(key: string, create?: boolean): symbol;
+    delete(key: string): void;
+    get size(): number;
+}
+/** Entry-local isolation realm. */
+export declare class LocalRealm extends Realm {
+    private entry;
+    constructor(entry: Entry);
+    get suffix(): string;
+}
+/** Named isolation realm shared by entries that use the same label. */
+export declare class GlobalRealm extends Realm {
+    label: string;
+    constructor(label: string);
+    get suffix(): string;
+}
+/** Install loader hooks that apply `intercept` and `isolate` entry options. */
+export default function isolate(ctx: Context): void;
+//# sourceMappingURL=isolate.d.ts.map

package/dist/kernel/cordis-plugin-loader/lib/types/config/isolate.js

@@ -0,0 +1,151 @@
+import { Context } from '../../../../cordis/lib/index.js';
+function swap(target, source) {
+    for (const key of Reflect.ownKeys(target)) {
+        Reflect.deleteProperty(target, key);
+    }
+    for (const key of Reflect.ownKeys(source || {})) {
+        Reflect.defineProperty(target, key, Reflect.getOwnPropertyDescriptor(source, key));
+    }
+}
+/** Symbol realm used to isolate service implementations by entry or label. */
+export class Realm {
+    store = Object.create(null);
+    access(key, create = false) {
+        if (create) {
+            return this.store[key] ??= Symbol(`${key}${this.suffix}`);
+        }
+        else {
+            return this.store[key] ?? Symbol(`${key}${this.suffix}`);
+        }
+    }
+    delete(key) {
+        delete this.store[key];
+    }
+    get size() {
+        return Object.keys(this.store).length;
+    }
+}
+/** Entry-local isolation realm. */
+export class LocalRealm extends Realm {
+    entry;
+    constructor(entry) {
+        super();
+        this.entry = entry;
+    }
+    get suffix() {
+        return '#' + this.entry.options.id;
+    }
+}
+/** Named isolation realm shared by entries that use the same label. */
+export class GlobalRealm extends Realm {
+    label;
+    constructor(label) {
+        super();
+        this.label = label;
+    }
+    get suffix() {
+        return '@' + this.label;
+    }
+}
+/** Install loader hooks that apply `intercept` and `isolate` entry options. */
+export default function isolate(ctx) {
+    const realms = Object.create(null);
+    const delims = Object.create(null);
+    function access(entry, name, create = false) {
+        let realm;
+        const label = entry.options.isolate?.[name];
+        if (!label)
+            return;
+        if (label === true) {
+            realm = entry.realm ??= new LocalRealm(entry);
+        }
+        else if (create) {
+            realm = realms[label] ??= new GlobalRealm(label);
+        }
+        else {
+            realm = realms[label];
+        }
+        return realm?.access(name, create);
+    }
+    ctx.on('loader/entry-init', (entry) => {
+        entry.ctx[Context.intercept] = Object.create(entry.ctx[Context.intercept]);
+        entry.ctx[Context.isolate] = Object.create(entry.ctx[Context.isolate]);
+    });
+    ctx.on('loader/patch-context', async (entry, next) => {
+        // step 1: generate new isolate map
+        const newMap = Object.create(entry.parent.ctx[Context.isolate]);
+        for (const name of Object.keys(entry.options.isolate ?? {})) {
+            newMap[name] = access(entry, name, true);
+        }
+        // step 2: generate service diff
+        const diff = Object.create(null);
+        const oldMap = entry.ctx[Context.isolate];
+        for (const name in { ...newMap, ...delims }) {
+            if (newMap[name] === oldMap[name])
+                continue;
+            const delim = delims[name] ??= Symbol(`delim:${name}`);
+            entry.ctx[delim] = Symbol(`${name}#${entry.id}`);
+            for (const symbol of [oldMap[name], newMap[name]]) {
+                const impl = symbol && entry.ctx.reflect.store[symbol];
+                if (!impl)
+                    continue;
+                if (!impl.fiber) {
+                    entry.ctx.logger.warn(new Error(`expected service ${name} to be implemented`));
+                    continue;
+                }
+                diff[name] = [oldMap[name], newMap[name], entry.ctx[delim], impl.fiber.ctx[delim]];
+                if (entry.ctx[delim] !== impl.fiber.ctx[delim])
+                    break;
+            }
+        }
+        // step 3: set prototype for transferred context
+        Object.setPrototypeOf(entry.ctx[Context.isolate], entry.parent.ctx[Context.isolate]);
+        Object.setPrototypeOf(entry.ctx[Context.intercept], entry.parent.ctx[Context.intercept]);
+        swap(entry.ctx[Context.isolate], newMap);
+        swap(entry.ctx[Context.intercept], entry.options.intercept);
+        // step 4: reload fiber
+        await next();
+        // step 5: replace service impl
+        for (const [symbol1, symbol2, flag1, flag2] of Object.values(diff)) {
+            if (flag1 === flag2 && entry.ctx.reflect.store[symbol1] && !entry.ctx.reflect.store[symbol2]) {
+                entry.ctx.reflect.store[symbol2] = entry.ctx.reflect.store[symbol1];
+                delete entry.ctx.reflect.store[symbol1];
+            }
+        }
+        // step 6: reflect notify
+        ctx.reflect.notify(Object.keys(diff), (ctx, name) => {
+            const [symbol1, symbol2, flag1, flag2] = diff[name];
+            const symbol3 = ctx[Context.isolate][name];
+            const flag3 = ctx[delims[name]];
+            return (symbol1 === symbol3 || symbol2 === symbol3) && (flag1 === flag3) !== (flag1 === flag2);
+        });
+        // step 7: clean up delimiters
+        for (const name in delims) {
+            if (!Reflect.ownKeys(newMap).includes(name)) {
+                delete entry.ctx[delims[name]];
+            }
+        }
+    });
+    ctx.on('loader/partial-dispose', (entry, legacy, active) => {
+        for (const [name, label] of Object.entries(legacy.isolate ?? {})) {
+            if (label === true)
+                continue;
+            if (active && entry.options.isolate?.[name] === label)
+                continue;
+            const realm = realms[label];
+            if (!realm)
+                continue;
+            // realm garbage collection
+            for (const entry of ctx.loader.entries()) {
+                // has reference to this realm
+                if (entry.options.isolate?.[name] === realm.label)
+                    return;
+            }
+            realm.delete(name);
+            if (!realm.size) {
+                delete realms[realm.label];
+            }
+        }
+    });
+}
+//# sourceMappingURL=isolate.js.map