@nomix-ai/nomix-harness 0.2.4 → 0.2.6

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

@@ -0,0 +1,38 @@
+import { Context } from '../../../../cordis/lib/index.js';
+import { type Dict } from '../../../../cosmokit/lib/index.js';
+import { Entry, type EntryOptions } from './entry.ts';
+import { EntryGroup } from './group.ts';
+/** Mutable tree of loader entries. Persistence is supplied by subclasses. */
+export declare abstract class EntryTree {
+    static readonly sep = ":";
+    ctx: Context;
+    enableLogs?: boolean;
+    root: EntryGroup;
+    store: Dict<Entry>;
+    constructor(ctx: Context);
+    get context(): Context;
+    /** Iterate entries in this tree and any nested subtrees. */
+    entries(): Generator<Entry, void, void>;
+    /** Return pending import and lifecycle tasks owned by this tree. */
+    getTasks(): Promise<void>[];
+    /**
+     * Wait until this tree has no active import or lifecycle tasks.
+     * @throws a settled fiber failure, or an aggregate when several fibers failed.
+     */
+    await(): Promise<void>;
+    ensureId(options: Partial<EntryOptions>): string;
+    /** Resolve an entry by id, including nested ids separated by `EntryTree.sep`. */
+    resolve(id: string): Entry;
+    resolveGroup(id: string | null): EntryGroup;
+    /** Create an entry in the root group or a nested group. */
+    create(options: Omit<EntryOptions, 'id'>, parent?: string | null, position?: number): Promise<string>;
+    /** Stop and remove an entry from its parent group. */
+    remove(id: string): Promise<void>;
+    /** Update an entry and optionally move it to another group. */
+    update(id: string, options: Omit<EntryOptions, 'id' | 'name'>, parent?: string | null, position?: number): Promise<void>;
+    /** Import a plugin module from a specifier or `cordis:` builtin. */
+    import(name: string, getOuterStack?: () => string[]): any;
+    /** Persist current tree state. In-memory trees may implement this as a no-op. */
+    abstract write(): void;
+}
+//# sourceMappingURL=tree.d.ts.map

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

@@ -0,0 +1,169 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { composeError } from '../../../../cordis/lib/index.js';
+import { isNonNullable } from '../../../../cosmokit/lib/index.js';
+import { EntryGroup } from "./group.js";
+/** Mutable tree of loader entries. Persistence is supplied by subclasses. */
+export class EntryTree {
+    static sep = ':';
+    ctx;
+    enableLogs;
+    root;
+    store = Object.create(null);
+    constructor(ctx) {
+        this.ctx = ctx.extend({ baseUrl: ctx.baseUrl });
+        this.root = new EntryGroup(this.ctx, this);
+        const entry = this.ctx.fiber.entry;
+        if (entry)
+            entry.subtree = this;
+    }
+    get context() {
+        return this.ctx;
+    }
+    /** Iterate entries in this tree and any nested subtrees. */
+    *entries() {
+        for (const entry of Object.values(this.store)) {
+            yield entry;
+            if (!entry.subtree)
+                continue;
+            yield* entry.subtree.entries();
+        }
+    }
+    /** Return pending import and lifecycle tasks owned by this tree. */
+    getTasks() {
+        return [...this.entries()]
+            .map(entry => entry._initTask || entry.fiber?.inertia)
+            .filter(isNonNullable);
+    }
+    /**
+     * Wait until this tree has no active import or lifecycle tasks.
+     * @throws a settled fiber failure, or an aggregate when several fibers failed.
+     */
+    async await() {
+        while (true) {
+            const tasks = this.getTasks();
+            if (tasks.length) {
+                await Promise.allSettled(tasks);
+                continue;
+            }
+            const outcomes = await Promise.allSettled([...this.entries()].map(entry => entry._await()));
+            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 fibers failed');
+            this.ctx.reflect.notify(['loader']);
+            if (!this.getTasks().length)
+                return;
+        }
+    }
+    ensureId(options) {
+        if (!options.id) {
+            do {
+                options.id = Math.random().toString(16).slice(2, 10);
+            } while (this.store[options.id]);
+        }
+        return options.id;
+    }
+    /** Resolve an entry by id, including nested ids separated by `EntryTree.sep`. */
+    resolve(id) {
+        const parts = id.split(EntryTree.sep);
+        let tree = this;
+        const final = parts.pop();
+        for (const part of parts) {
+            tree = tree.store[part]?.subtree;
+            if (!tree)
+                throw new Error(`cannot resolve entry ${id}`);
+        }
+        const entry = tree.store[final];
+        if (!entry)
+            throw new Error(`cannot resolve entry ${id}`);
+        return entry;
+    }
+    resolveGroup(id) {
+        if (!id)
+            return this.root;
+        const entry = this.resolve(id);
+        if (!entry.subgroup)
+            throw new Error(`entry ${id} is not a group`);
+        return entry.subgroup;
+    }
+    /** Create an entry in the root group or a nested group. */
+    async create(options, parent = null, position = Infinity) {
+        const group = this.resolveGroup(parent);
+        const id = await group.create(options);
+        const entry = this.resolve(id);
+        group.data.splice(position, 0, entry.options);
+        group.tree.write();
+        return id;
+    }
+    /** Stop and remove an entry from its parent group. */
+    async remove(id) {
+        const entry = this.resolve(id);
+        await entry.parent.remove(id);
+        entry.parent.tree.write();
+    }
+    /** Update an entry and optionally move it to another group. */
+    async update(id, options, parent, position) {
+        const entry = this.resolve(id);
+        const source = entry.parent;
+        const sourceIndex = source.data.indexOf(entry.options);
+        let target = source;
+        if (parent !== undefined) {
+            target = this.resolveGroup(parent);
+            source.unlink(entry.options);
+            target.data.splice(position ?? Infinity, 0, entry.options);
+            entry.parent = target;
+        }
+        try {
+            await entry.update(options, false, true);
+        }
+        catch (error) {
+            if (parent !== undefined) {
+                target.unlink(entry.options);
+                source.data.splice(sourceIndex < 0 ? source.data.length : sourceIndex, 0, entry.options);
+                entry.parent = source;
+                try {
+                    await entry.update({}, false, true);
+                }
+                catch (rollbackError) {
+                    throw new AggregateError([error, rollbackError], `failed to roll back loader entry move ${id}`);
+                }
+            }
+            throw error;
+        }
+        source.tree.write();
+        if (target !== source)
+            target.tree.write();
+    }
+    /** Import a plugin module from a specifier or `cordis:` builtin. */
+    import(name, getOuterStack) {
+        if (name.startsWith('cordis:')) {
+            return this.ctx.loader.builtins[name.slice(7)];
+        }
+        return composeError(async (info) => {
+            // ModuleJob.run
+            // onImport.tracePromise.__proto__
+            // internal.import
+            info.offset += 3;
+            if (this.ctx.loader.internal) {
+                return await this.ctx.loader.internal.import(name, this.ctx.baseUrl, {});
+            }
+            else if (name.startsWith('.')) {
+                return await import(__rewriteRelativeImportExtension(/* @vite-ignore */ new URL(name, this.ctx.baseUrl).href));
+            }
+            else {
+                return await import(__rewriteRelativeImportExtension(/* @vite-ignore */ name));
+            }
+        }, getOuterStack);
+    }
+}
+//# sourceMappingURL=tree.js.map

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

@@ -0,0 +1,11 @@
+/** Evaluate a JavaScript expression against a loader context scope. */
+export declare const evaluate: ((ctx: object, expr: string) => any);
+/** Recursively replace YAML `!js` expression nodes with evaluated values. */
+export declare function interpolate(ctx: object, value: any): any;
+/** Return true when a value is a serialized loader JavaScript expression. */
+export declare function isJsExpr(value: any): value is JsExpr;
+/** Serialized JavaScript expression produced by the include YAML tag. */
+export interface JsExpr {
+    __jsExpr: string;
+}
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,28 @@
+import { valueMap } from '../../../../cosmokit/lib/index.js';
+// eslint-disable-next-line no-new-func
+/** Evaluate a JavaScript expression against a loader context scope. */
+export const evaluate = new Function('ctx', 'expr', `
+  with (ctx) {
+    return eval(expr)
+  }
+`);
+/** Recursively replace YAML `!js` expression nodes with evaluated values. */
+export function interpolate(ctx, value) {
+    if (isJsExpr(value)) {
+        return evaluate(ctx, value.__jsExpr);
+    }
+    else if (!value || typeof value !== 'object') {
+        return value;
+    }
+    else if (Array.isArray(value)) {
+        return value.map(item => interpolate(ctx, item));
+    }
+    else {
+        return valueMap(value, item => interpolate(ctx, item));
+    }
+}
+/** Return true when a value is a serialized loader JavaScript expression. */
+export function isJsExpr(value) {
+    return value instanceof Object && '__jsExpr' in value;
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,73 @@
+import { Context, Service, type Fiber } from '../../../cordis/lib/index.js';
+import { type Dict } from '../../../cosmokit/lib/index.js';
+import { ModuleLoader } from './internal.ts';
+import { Entry, type EntryOptions } from './config/entry.ts';
+import { EntryTree } from './config/tree.ts';
+/** Re-export entry node APIs. */
+export * from './config/entry.ts';
+/** Re-export nested entry group APIs. */
+export * from './config/group.ts';
+/** Re-export service isolation helpers. */
+export * from './config/isolate.ts';
+/** Re-export entry tree persistence APIs. */
+export * from './config/tree.ts';
+/** Re-export loader config expression helpers. */
+export * from './config/utils.ts';
+/** Re-export Node internal module loader compatibility types. */
+export * from './internal.ts';
+declare module '@nomix-ai/cordis' {
+    interface Events {
+        'exit'(signal: NodeJS.Signals): Promise<void>;
+        'loader/config-update'(): void;
+        'loader/entry-init'(entry: Entry): void;
+        'loader/partial-dispose'(entry: Entry, legacy: Partial<EntryOptions>, active: boolean): void;
+        'loader/patch-context'(entry: Entry, next: () => void | Promise<void>): void | Promise<void>;
+    }
+    interface Context {
+        loader: Loader;
+    }
+    interface EnvData {
+        startTime?: number;
+    }
+    interface Fiber {
+        entry?: Entry;
+    }
+}
+/** Loader config and dependency intercept namespace. */
+export declare namespace Loader {
+    /** Root loader configuration. */
+    interface Config {
+        /** Base URL used to resolve relative plugin specifiers and config paths. */
+        baseUrl?: string;
+    }
+    /** Intercept config used when other plugins depend on `loader`. */
+    interface Intercept {
+        /** Keep dependent plugins pending while loader entries are still loading. */
+        await?: boolean;
+    }
+}
+/**
+ * Service that owns a loader entry tree and imports configured plugins.
+ *
+ * Subclasses provide persistence by implementing `write()` on `EntryTree`.
+ */
+export declare class Loader extends EntryTree {
+    config: Loader.Config;
+    [Service.config]: Loader.Intercept;
+    envData: any;
+    name: string;
+    internal: ModuleLoader | undefined;
+    builtins: Dict<any>;
+    constructor(ctx: Context, config?: Loader.Config);
+    write(): void;
+    [Service.check](): boolean;
+    showLog(entry: Entry, type: string): void;
+    /** Return the loader entry id that owns `fiber`, if any. */
+    locate(fiber?: Fiber): string | undefined;
+    /** Hook for hosts that can restart the process on full-reload requests. */
+    exit(): void;
+    /** Normalize ESM/CJS/default export shapes before applying a plugin. */
+    unwrapExports(exports: any): any;
+}
+export default Loader;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,154 @@
+import { Inject, Service } from '../../../cordis/lib/index.js';
+import { defineProperty, isNullable } from '../../../cosmokit/lib/index.js';
+import { ModuleLoader } from "./internal.js";
+import { Entry } from "./config/entry.js";
+import { EntryGroup } from "./config/group.js";
+import isolate from "./config/isolate.js";
+import { EntryTree } from "./config/tree.js";
+import { interpolate } from "./config/utils.js";
+/** Re-export entry node APIs. */
+export * from "./config/entry.js";
+/** Re-export nested entry group APIs. */
+export * from "./config/group.js";
+/** Re-export service isolation helpers. */
+export * from "./config/isolate.js";
+/** Re-export entry tree persistence APIs. */
+export * from "./config/tree.js";
+/** Re-export loader config expression helpers. */
+export * from "./config/utils.js";
+/** Re-export Node internal module loader compatibility types. */
+export * from "./internal.js";
+/**
+ * Service that owns a loader entry tree and imports configured plugins.
+ *
+ * Subclasses provide persistence by implementing `write()` on `EntryTree`.
+ */
+export class Loader extends EntryTree {
+    config;
+    envData = process.env.CORDIS_SHARED
+        ? JSON.parse(process.env.CORDIS_SHARED)
+        : { startTime: Date.now() };
+    name = 'loader';
+    internal = ModuleLoader.fromInternal();
+    builtins = Object.create(null);
+    constructor(ctx, config = {}) {
+        super(ctx);
+        this.config = config;
+        if (config.baseUrl) {
+            this.ctx.baseUrl = config.baseUrl;
+        }
+        const self = this;
+        defineProperty(this, Service.tracker, {
+            associate: 'loader',
+            property: 'ctx',
+            noShadow: true,
+        });
+        ctx.reflect.provide('loader', this, this[Service.check]);
+        ctx.on('internal/config', function (_config, next) {
+            const config = next();
+            if (!this.entry || this.parent.fiber?.entry === this.entry)
+                return config;
+            // Tree carriers (Group, Include) keep their configs literal: their
+            // entry and patch lists hold other rows' configs, whose `!!js`
+            // expressions belong to those rows' own fibers.
+            const plugin = this.runtime?.callback;
+            if (plugin?.[EntryGroup.key])
+                return config;
+            return interpolate(this.ctx, config);
+        }, { global: true });
+        ctx.on('internal/update', async function (config, noSave, next) {
+            if (!this.entry || noSave || this.parent.fiber?.entry === this.entry)
+                return next();
+            await next();
+            const unparse = this.runtime?.Config?.['simplify'];
+            this.entry.options.config = unparse ? unparse(config) : config;
+            this.entry.parent.tree.write();
+        }, { global: true, prepend: true });
+        ctx.on('internal/update', function (config, _, next) {
+            if (!this.entry || this.parent.fiber?.entry === this.entry)
+                return next();
+            self.showLog(this.entry, 'reload');
+            return next();
+        }, { global: true });
+        ctx.on('internal/plugin', (fiber) => {
+            // 1. set `fiber.entry`
+            if (fiber.parent[Entry.key] && !fiber.entry) {
+                fiber.entry = fiber.parent[Entry.key];
+                // FIXME merge config
+                Inject.resolve(fiber.entry.options.inject, fiber.inject);
+            }
+            // 2. handle self-dispose
+            // We only care about `ctx.fiber.dispose()`, so we need to filter out other cases.
+            // case 1: fiber is created
+            if (fiber.uid)
+                return;
+            // case 2: fiber is not tracked by loader
+            if (!fiber.entry)
+                return;
+            // case 3: fiber is a child plugin under the entry (not the entry's root fiber)
+            if (fiber.parent.fiber?.entry === fiber.entry)
+                return;
+            // case 4: fiber is disposed on behalf of plugin deletion (such as plugin hmr)
+            // self-dispose: ctx.fiber.dispose() -> fiber / runtime dispose -> delete(plugin)
+            // plugin hmr: delete(plugin) -> runtime dispose -> fiber dispose
+            if (!ctx.registry.has(fiber.runtime.callback))
+                return;
+            // case 5: the entry's tree is being disposed
+            const treeOwner = fiber.entry.parent.tree.ctx.fiber;
+            if (!treeOwner.uid || treeOwner.state === 5 /* FiberState.UNLOADING */)
+                return;
+            // case 6: Loader is replacing or removing this exact fiber
+            if (fiber.entry._disposing)
+                return;
+            this.showLog(fiber.entry, 'unload');
+            // case 7: fiber is disposed by loader behavior
+            // such as inject checker, config file update, ancestor group disable
+            if (fiber.entry.disabled)
+                return;
+            fiber.entry.options.disabled = true;
+            fiber.entry.parent.tree.write();
+        });
+        ctx.plugin(isolate);
+    }
+    write() {
+        // Loader's root tree is in-memory; writes are no-ops.
+    }
+    [Service.check]() {
+        const config = Service.prototype[Service.resolveConfig].call(this);
+        if (config.await && this.getTasks().length)
+            return false;
+        return true;
+    }
+    showLog(entry, type) {
+        if (entry.options.group || !entry.parent.tree.enableLogs)
+            return;
+        this.ctx.root.logger?.('loader').info('%s plugin %C', type, entry.options.name);
+    }
+    /** Return the loader entry id that owns `fiber`, if any. */
+    locate(fiber = this.ctx.fiber) {
+        while (1) {
+            if (fiber.entry)
+                return fiber.entry.id;
+            const next = fiber.parent.fiber;
+            if (fiber === next)
+                return;
+            fiber = next;
+        }
+    }
+    /** Hook for hosts that can restart the process on full-reload requests. */
+    exit() {
+    }
+    /** Normalize ESM/CJS/default export shapes before applying a plugin. */
+    unwrapExports(exports) {
+        if (isNullable(exports))
+            return exports;
+        exports = exports.default ?? exports;
+        // https://github.com/evanw/esbuild/issues/2623
+        // https://esbuild.github.io/content-types/#default-interop
+        if (!exports.__esModule)
+            return exports;
+        return exports.default ?? exports;
+    }
+}
+export default Loader;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,97 @@
+import { type LoadHookContext } from 'node:module';
+import type { Dict } from '../../../cosmokit/lib/index.js';
+/** Node internal module format names handled by loader hooks. */
+export type ModuleFormat = 'builtin' | 'commonjs' | 'json' | 'module' | 'wasm';
+/** Source payload accepted by Node internal module load hooks. */
+export type ModuleSource = string | ArrayBuffer;
+/** Result returned by a Node internal resolve hook. */
+export interface ResolveResult {
+    format: ModuleFormat;
+    url: string;
+}
+/** Result returned by a Node internal load hook. */
+export interface LoadResult {
+    format: ModuleFormat;
+    source?: ModuleSource;
+}
+type LoadCacheData = ModuleJob;
+/** @see https://github.com/nodejs/node/blob/main/lib/internal/modules/esm/module_map.js */
+interface LoadCache extends Omit<Map<string, Dict<LoadCacheData>>, 'get' | 'set' | 'has'> {
+    get(url: string, type?: string): LoadCacheData | undefined;
+    set(url: string, type?: string, job?: LoadCacheData): this;
+    has(url: string, type?: string): boolean;
+}
+/** Minimal Node internal ModuleWrap surface used by HMR helpers. */
+export interface ModuleWrap {
+    url: string;
+    getNamespace(): any;
+}
+/** @see https://github.com/nodejs/node/blob/main/lib/internal/modules/esm/module_job.js */
+export interface ModuleJob {
+    url: string;
+    loader: ModuleLoader;
+    module?: ModuleWrap;
+    importAttributes: ImportAttributes;
+    linked: Promise<ModuleJob[]>;
+    instantiate(): Promise<void>;
+    run(): Promise<{
+        module: ModuleWrap;
+    }>;
+}
+/**
+ * Node 22/23 ModuleLoader interface.
+ *
+ * Key methods:
+ * - getModuleJobForImport(specifier, parentURL, importAttributes)
+ * - resolve(specifier, parentURL, importAttributes) → Promise<ResolveResult>
+ * - resolveSync(specifier, parentURL, importAttributes) → ResolveResult
+ */
+export interface ModuleLoaderV1 {
+    version: 'v1';
+    loadCache: LoadCache;
+    import(specifier: string, parentURL: string, importAttributes: ImportAttributes): Promise<any>;
+    register(specifier: string | URL, parentURL?: string | URL, data?: any, transferList?: any[]): void;
+    getModuleJobForImport(specifier: string, parentURL: string, importAttributes: ImportAttributes): Promise<ModuleJob>;
+    resolve(specifier: string, parentURL: string, importAttributes: ImportAttributes): Promise<ResolveResult>;
+    resolveSync(specifier: string, parentURL: string, importAttributes: ImportAttributes): ResolveResult;
+    load(specifier: string, context: Pick<LoadHookContext, 'format' | 'importAttributes'>): Promise<LoadResult>;
+}
+/** Node 24+ module request object. */
+export interface ModuleRequest {
+    specifier: string;
+    attributes?: ImportAttributes;
+    phase?: ModulePhase;
+}
+/** @see https://github.com/nodejs/node/blob/main/src/module_wrap.h */
+export declare const enum ModulePhase {
+    Source = 1,
+    Evaluation = 2
+}
+/** Opaque Node internal module request type marker. */
+export type ModuleRequestType = unknown;
+/**
+ * Node 24+ ModuleLoader interface.
+ *
+ * Breaking changes from v1:
+ * - getModuleJobForImport removed → getOrCreateModuleJob(parentURL, request, requestType)
+ * - resolve removed (became private #resolve) → resolveSync(parentURL, request)
+ * - Parameter order reversed for resolveSync, request object { specifier, attributes }
+ * - LoadCache became typed Map<url, { [type]: ModuleJob }> with delete only setting undefined
+ */
+export interface ModuleLoaderV2 {
+    version: 'v2';
+    loadCache: LoadCache;
+    import(specifier: string, parentURL: string, importAttributes: ImportAttributes, phase?: ModulePhase, isEntryPoint?: boolean): Promise<any>;
+    register(specifier: string | URL, parentURL?: string | URL, data?: any, transferList?: any[], isInternal?: boolean): void;
+    getOrCreateModuleJob(parentURL: string, request: ModuleRequest, requestType?: ModuleRequestType): Promise<ModuleJob>;
+    resolveSync(parentURL: string, request: ModuleRequest): ResolveResult;
+    load(url: string, context: Pick<LoadHookContext, 'format' | 'importAttributes'>): Promise<LoadResult>;
+}
+/** Supported Node internal ESM loader shapes. */
+export type ModuleLoader = ModuleLoaderV1 | ModuleLoaderV2;
+/** Helpers for locating the current Node internal module loader. */
+export declare namespace ModuleLoader {
+    function fromInternal(): ModuleLoader | undefined;
+}
+export {};
+//# sourceMappingURL=internal.d.ts.map

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

@@ -0,0 +1,36 @@
+import { createRequire } from 'node:module';
+/** Helpers for locating the current Node internal module loader. */
+export var ModuleLoader;
+(function (ModuleLoader) {
+    let _cachedLoader;
+    function requireInternal(id) {
+        const require = createRequire(import.meta.url);
+        if (process.execArgv.includes('--expose-internals')) {
+            try {
+                return require(id);
+            }
+            catch { }
+        }
+        try {
+            return require('node-addon-require-builtin').requireBuiltin(id);
+        }
+        catch { }
+    }
+    function fromInternal() {
+        if (_cachedLoader)
+            return _cachedLoader;
+        const [major] = process.versions.node.split('.').map(Number);
+        if (major >= 24) {
+            const raw = requireInternal('internal/modules/esm/loader')?.getOrInitializeCascadedLoader();
+            if (raw)
+                return _cachedLoader = Object.assign(raw, { version: 'v2' });
+        }
+        else if (major >= 22) {
+            const raw = requireInternal('internal/modules/esm/loader')?.getOrInitializeCascadedLoader();
+            if (raw)
+                return _cachedLoader = Object.assign(raw, { version: 'v1' });
+        }
+    }
+    ModuleLoader.fromInternal = fromInternal;
+})(ModuleLoader || (ModuleLoader = {}));
+//# sourceMappingURL=internal.js.map

package/dist/kernel/cordis-plugin-loader/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@nomix-ai/cordis-plugin-loader",
+  "description": "Plugin loader for cordis",
+  "version": "1.0.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ditgaldev/nomix-harness.git",
+    "directory": "vendor/loader"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts",
+    "lib/types/**/*.d.ts.map",
+    "src"
+  ],
+  "author": "Shigma <shigma10826@gmail.com>",
+  "license": "MIT",
+  "peerDependencies": {
+    "@nomix-ai/cordis": "workspace:^",
+    "node-addon-require-builtin": "^0.1.4"
+  },
+  "peerDependenciesMeta": {
+    "node-addon-require-builtin": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@nomix-ai/cosmokit": "workspace:^"
+  }
+}