@nomix-ai/nomix-harness 0.2.4 → 0.2.6

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

@@ -0,0 +1,105 @@
+import { Context } from './context.ts';
+import { Fiber } from './fiber.ts';
+import { symbols } from './utils.ts';
+declare module './context.ts' {
+    interface Intercept {
+        logger: LoggerService.Intercept;
+    }
+}
+/** Logger method name and severity category. */
+export type LoggerType = 'error' | 'info' | 'warn' | 'debug';
+/** Callable shape for one logger severity method. */
+export type LoggerMethod = (format: any, ...param: any[]) => void;
+/** Formatter used to resolve a printf-style placeholder. */
+export type Formatter = (value: any, exporter: Exporter, message: Message) => any;
+/** Numeric severity used when exporters decide whether to emit a message. */
+export declare const enum LoggerLevel {
+    ERROR = 0,
+    INFO = 1,
+    WARN = 2,
+    DEBUG = 3
+}
+/** Structured log record delivered to exporters. */
+export interface Message {
+    sn: number;
+    ts: number;
+    name: string;
+    type: LoggerType;
+    level: number;
+    args: any[];
+    fiber?: WeakRef<Fiber>;
+}
+/** Sink that receives structured log messages. */
+export interface Exporter {
+    colors?: number | false;
+    maxLength?: number;
+    levels?: Record<string, number>;
+    formatters?: Record<string, Formatter>;
+    export(message: Message): void;
+}
+/** Built-in placeholder formatters used by `Logger.format()`. */
+export declare const defaultFormatters: Record<string, Formatter>;
+/** Options used when creating a named logger facade. */
+export interface LoggerOptions {
+    /** The logger name shown with each message. */
+    name: string;
+    /** Message fields merged into every record from this logger. */
+    meta?: Partial<Message>;
+    /** Default maximum level exported when an exporter has no own threshold. */
+    level?: number;
+}
+/** Logger facade identity, inherited message metadata, and optional minimum level. */
+export interface Logger extends LoggerOptions {
+}
+/** Logger facade severity methods. */
+export interface Logger extends Record<LoggerType, LoggerMethod> {
+}
+/** Logger facade for one named subsystem. */
+export declare class Logger {
+    private service;
+    static color(exporter: Exporter, code: number, value: any, decoration?: string): string;
+    static code(name: string, level?: false | number): number;
+    static format(exporter: Exporter, message: Message): string;
+    constructor(options: LoggerOptions, service: LoggerService);
+    private _method;
+}
+/** ANSI 16-color palette indexes used for logger name coloring. */
+export declare const c16: number[];
+/** ANSI 256-color palette indexes used for logger name coloring. */
+export declare const c256: number[];
+/** Logger service configuration merged from context intercepts. */
+export declare namespace LoggerService {
+    interface Intercept {
+        name?: string;
+        level?: number;
+    }
+}
+/** Callable `ctx.logger` service shape. */
+export interface LoggerService extends Record<LoggerType, LoggerMethod> {
+    (name?: string): Logger;
+}
+/**
+ * Built-in logging service.
+ *
+ * Call `ctx.logger()` to create a named logger, or call `ctx.logger.info()`
+ * directly to log with the current fiber-derived name.
+ */
+export declare class LoggerService {
+    bufferSize: number;
+    buffer: Message[];
+    ctx: Context;
+    _snMessage: number;
+    _snExporter: number;
+    exporters: Map<number, Exporter>;
+    constructor(ctx: Context);
+    /**
+     * Register an exporter and dispose it with the current fiber.
+     *
+     * @param exporter — the sink that receives structured log messages.
+     * @returns a disposer that removes the exporter.
+     */
+    exporter(exporter: Exporter): import("./fiber.ts").Disposable<Promise<void>>;
+    private _resolveConfig;
+    [symbols.invoke](name?: string): Logger;
+}
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1,185 @@
+import { defineProperty, hyphenate } from '../../../cosmokit/lib/index.js';
+import { createCallable, joinPrototype, symbols } from "./utils.js";
+/** Built-in placeholder formatters used by `Logger.format()`. */
+export const defaultFormatters = {
+    s: (value) => String(value),
+    d: (value) => Math.trunc(Number(value)),
+    i: (value) => Math.trunc(Number(value)),
+    f: (value) => Number(value),
+    o: (value) => JSON.stringify(value),
+    O: (value) => JSON.stringify(value),
+    c: () => '',
+    C: (value, exporter, message) => {
+        return Logger.color(exporter, Logger.code(message.name, exporter.colors), value);
+    },
+};
+function isAggregateError(error) {
+    return error instanceof Error && Array.isArray(error['errors']);
+}
+/** Logger facade for one named subsystem. */
+export class Logger {
+    service;
+    static color(exporter, code, value, decoration = '') {
+        if (!exporter.colors)
+            return '' + value;
+        return `\u001b[3${code < 8 ? code : '8;5;' + code}${exporter.colors >= 2 ? decoration : ''}m${value}\u001b[0m`;
+    }
+    static code(name, level) {
+        let hash = 0;
+        for (let i = 0; i < name.length; i++) {
+            hash = ((hash << 3) - hash) + name.charCodeAt(i) + 13;
+            hash |= 0;
+        }
+        const colors = !level ? [] : level >= 2 ? c256 : c16;
+        return colors[Math.abs(hash) % colors.length];
+    }
+    static format(exporter, message) {
+        const args = message.args.slice();
+        if (args[0] instanceof Error) {
+            args[0] = args[0].stack || args[0].message;
+            args.unshift('%s');
+        }
+        else if (typeof args[0] !== 'string') {
+            args.unshift('%o');
+        }
+        let format = args.shift();
+        format = format.replace(/%([a-zA-Z%])/g, (match, char) => {
+            if (match === '%%')
+                return '%';
+            const formatter = exporter.formatters?.[char] ?? defaultFormatters[char];
+            if (typeof formatter === 'function') {
+                const value = args.shift();
+                return formatter(value, exporter, message);
+            }
+            return match;
+        });
+        const oFormatter = exporter.formatters?.o ?? defaultFormatters.o;
+        for (let arg of args) {
+            if (typeof arg === 'object' && arg) {
+                arg = oFormatter(arg, exporter, message);
+            }
+            format += ' ' + arg;
+        }
+        const { maxLength = 10240 } = exporter;
+        return format.split(/\r?\n/g).map(line => {
+            return line.slice(0, maxLength) + (line.length > maxLength ? '...' : '');
+        }).join('\n');
+    }
+    constructor(options, service) {
+        this.service = service;
+        Object.assign(this, options);
+        this.error = this._method('error', 0 /* LoggerLevel.ERROR */);
+        this.info = this._method('info', 1 /* LoggerLevel.INFO */);
+        this.warn = this._method('warn', 2 /* LoggerLevel.WARN */);
+        this.debug = this._method('debug', 3 /* LoggerLevel.DEBUG */);
+    }
+    _method(type, level) {
+        return (...args) => {
+            if (args.length === 1 && args[0] instanceof Error) {
+                if (args[0].cause) {
+                    this[type](args[0].cause);
+                }
+                else if (isAggregateError(args[0])) {
+                    args[0].errors.forEach(error => this[type](error));
+                    return;
+                }
+            }
+            const sn = ++this.service._snMessage;
+            const ts = Date.now();
+            for (const exporter of this.service.exporters.values()) {
+                const targetLevel = exporter.levels?.[this.name] ?? exporter.levels?.default ?? this.level ?? 1 /* LoggerLevel.INFO */;
+                if (targetLevel < level)
+                    continue;
+                const message = { sn, ts, type, level, name: this.name, ...this.meta, args };
+                exporter.export(message);
+            }
+        };
+    }
+}
+/** ANSI 16-color palette indexes used for logger name coloring. */
+export const c16 = [6, 2, 3, 4, 5, 1];
+/** ANSI 256-color palette indexes used for logger name coloring. */
+export const c256 = [
+    20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62,
+    63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113,
+    129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168,
+    169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200,
+    201, 202, 203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221,
+];
+/**
+ * Built-in logging service.
+ *
+ * Call `ctx.logger()` to create a named logger, or call `ctx.logger.info()`
+ * directly to log with the current fiber-derived name.
+ */
+export class LoggerService {
+    bufferSize = 1000;
+    buffer = [];
+    ctx;
+    _snMessage = 0;
+    _snExporter = 0;
+    exporters = new Map();
+    constructor(ctx) {
+        const tracker = {
+            property: 'ctx',
+            noShadow: true,
+        };
+        const self = createCallable('logger', joinPrototype(Object.getPrototypeOf(this), Function.prototype), tracker);
+        Object.assign(self, this);
+        self.ctx = ctx;
+        defineProperty(self, symbols.tracker, tracker);
+        self.exporter({
+            colors: 3,
+            export: (message) => {
+                self.buffer.push(message);
+                if (self.buffer.length > self.bufferSize) {
+                    self.buffer = self.buffer.slice(-self.bufferSize);
+                }
+            },
+        });
+        return self;
+    }
+    /**
+     * Register an exporter and dispose it with the current fiber.
+     *
+     * @param exporter — the sink that receives structured log messages.
+     * @returns a disposer that removes the exporter.
+     */
+    exporter(exporter) {
+        return this.ctx.effect(() => {
+            this.exporters.set(++this._snExporter, exporter);
+            return () => this.exporters.delete(this._snExporter);
+        }, 'ctx.logger.exporter()');
+    }
+    _resolveConfig() {
+        let intercept = this.ctx[symbols.intercept];
+        const configs = [];
+        while ('logger' in intercept) {
+            if (Object.hasOwn(intercept, 'logger')) {
+                configs.unshift(intercept['logger']);
+            }
+            intercept = Object.getPrototypeOf(intercept);
+        }
+        return Object.assign({}, ...configs);
+    }
+    [symbols.invoke](name) {
+        const config = this._resolveConfig();
+        const fiber = (this.ctx[symbols.shadow] ?? this.ctx).fiber;
+        name ??= config.name;
+        name ??= hyphenate(fiber.name);
+        return new Logger({
+            name,
+            level: config.level,
+            meta: { fiber: new WeakRef(fiber) },
+        }, this);
+    }
+    static {
+        for (const type of ['error', 'info', 'warn', 'debug']) {
+            ;
+            LoggerService.prototype[type] = function (...args) {
+                return this()[type](...args);
+            };
+        }
+    }
+}
+//# sourceMappingURL=logger.js.map

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

@@ -0,0 +1,186 @@
+import type { Dict } from '../../../cosmokit/lib/index.js';
+import { Context } from './context.ts';
+import { Fiber } from './fiber.ts';
+declare module './context.ts' {
+    interface Context {
+        /**
+         * Read a service from the store without the inject requirement.
+         *
+         * @param name — the service name.
+         * @param strict — when `true` (default), only return implementations
+         * whose providing fiber is currently active.
+         * @returns the service value, or `undefined` when not (yet) provided.
+         */
+        get<K extends string & keyof this>(name: K, strict?: boolean): undefined | this[K];
+        /** Same as above for service names outside the typed `Context` surface. */
+        get(name: string, strict?: boolean): any;
+        /**
+         * Overwrite a provided service's value.
+         *
+         * Only the fiber that provided the service may set it; setting an
+         * unprovided name throws.
+         *
+         * @param name — the service name.
+         * @param value — the new service value.
+         */
+        set<K extends string & keyof this>(name: K, value: undefined | this[K]): void;
+        /** Same as above for service names outside the typed `Context` surface. */
+        set(name: string, value: any): void;
+        /**
+         * Register a service implementation owned by the current fiber.
+         *
+         * The service becomes visible to dependents in the same isolation scope
+         * once the fiber is active; it is unregistered (waking dependents) when
+         * the returned disposer runs or the fiber unloads. Throws if the name is
+         * already provided in this scope or declared as an accessor.
+         *
+         * @param name — the service name.
+         * @param value — the service value.
+         * @returns a disposer that unregisters the service.
+         */
+        provide<K extends string & keyof this>(name: K, value: undefined | this[K]): () => void;
+        /** Same as above for service names outside the typed `Context` surface. */
+        provide(name: string, value?: any): () => void;
+        /**
+         * Define a computed context property backed by get/set hooks.
+         *
+         * The accessor is removed when the current fiber unloads. Throws if the
+         * name is already declared.
+         *
+         * @param name — the context property name.
+         * @param options — the `get` hook and optional `set` hook.
+         */
+        accessor(name: string, options: Omit<Property.Accessor, 'type'>): void;
+        /**
+         * Expose selected members of a service directly on `ctx`.
+         *
+         * Each mixed-in key becomes an accessor that forwards to the service
+         * (binding methods to it), so e.g. `ctx.on` forwards to `ctx.events.on`.
+         * Mixins are removed when the current fiber unloads.
+         *
+         * @param name — the context property holding the source service.
+         * @param mixins — keys to forward, or a source-key → ctx-key map.
+         */
+        mixin<K extends string & keyof this>(name: K, mixins: (keyof this & keyof this[K])[] | Dict<string>): void;
+        /** Same as above with a source object instead of a context property name. */
+        mixin<T extends {}>(source: T, mixins: (keyof this & keyof T)[] | Dict<string>): void;
+    }
+}
+/** Context property definition known by the reflection service. */
+export type Property = Property.Service | Property.Accessor;
+/** Property definition variants understood by `ReflectService`. */
+export declare namespace Property {
+    /** Service property backed by a provided implementation. */
+    interface Service {
+        /** Discriminator. */
+        type: 'service';
+    }
+    /** Computed context property backed by custom get/set hooks. */
+    interface Accessor {
+        /** Discriminator. */
+        type: 'accessor';
+        /** Compute the property value; `error` carries the caller stack for diagnostics. */
+        get: (this: Context, receiver: any, error: Error) => any;
+        /** Optional setter; return `false` to reject the write. */
+        set?: (this: Context, value: any, receiver: any, error: Error) => boolean;
+    }
+}
+/** Concrete service implementation record stored in the root reflect service. */
+export interface Impl {
+    /** The service name. */
+    name: string;
+    /** The fiber that provided the service (owns its lifetime). */
+    fiber: Fiber;
+    /** The current service value. */
+    value?: any;
+    /** Optional availability predicate consulted before dependents may load. */
+    check?: () => boolean;
+}
+/**
+ * Reflection and service-resolution layer installed as `ctx.reflect`.
+ *
+ * This service powers the context proxy, service registration, accessors, and
+ * the mixins that expose core service methods directly on `ctx`.
+ */
+export declare class ReflectService {
+    ctx: Context;
+    /** Proxy traps implementing service resolution for every context object. */
+    static handler: ProxyHandler<Context>;
+    /** Service implementations, keyed by isolation label. */
+    store: Dict<Impl, symbol>;
+    /** Declared context properties (services and accessors), by name. */
+    props: Dict<Property>;
+    constructor(ctx: Context);
+    /**
+     * Read a service from the store without the inject requirement.
+     *
+     * @param name — the service name.
+     * @param strict — when `true`, only return implementations whose providing
+     * fiber is currently active.
+     * @returns the service value, or `undefined` when not (yet) provided.
+     */
+    get(name: string, strict?: boolean): any;
+    _getImpl(name: string, strict?: boolean): Impl | undefined;
+    /**
+     * Overwrite a provided service's value.
+     *
+     * @param name — the service name.
+     * @param value — the new service value.
+     * @param error — carrier for the caller stack in diagnostics.
+     * @returns `true` on success.
+     * @throws when `name` was never provided, or was provided by another fiber.
+     */
+    set(name: string, value: any, error?: Error): boolean;
+    /**
+     * Register a service implementation owned by the current fiber.
+     *
+     * See the `ctx.provide()` overload above for the full contract.
+     *
+     * @param name — the service name.
+     * @param value — the service value.
+     * @param check — optional availability predicate for dependents.
+     * @returns a disposer that unregisters the service.
+     */
+    provide(name: string, value?: any, check?: () => boolean): import("./fiber.ts").Disposable<Promise<void>>;
+    /**
+     * Re-evaluate every fiber that requires one of the given services.
+     *
+     * @param names — the service names that changed.
+     * @param filter — restricts notification to matching isolation scopes.
+     * @returns the fibers whose dependency state was refreshed.
+     */
+    notify(names: string[], filter?: (ctx: Context, name: string) => boolean): Fiber[];
+    /**
+     * Define a computed context property backed by get/set hooks.
+     *
+     * @param name — the context property name.
+     * @param options — the `get` hook and optional `set` hook.
+     * @returns a disposer that removes the accessor.
+     */
+    accessor(name: string, options: Omit<Property.Accessor, 'type'>): import("./fiber.ts").Disposable<Promise<void>>;
+    /**
+     * Expose selected members of a service directly on `ctx`.
+     *
+     * See the `ctx.mixin()` overload above for the full contract.
+     *
+     * @param source — a context property name or a source object.
+     * @param mixins — keys to forward, or a source-key → ctx-key map.
+     * @returns a disposer that removes all created accessors.
+     */
+    mixin(source: any, mixins: string[] | Dict<string>): import("./fiber.ts").Disposable<Promise<void>>;
+    /**
+     * Attach this context's tracing wrapper to a value.
+     *
+     * @param value — the value to wrap.
+     * @returns the traceable wrapper (or the value itself when not applicable).
+     */
+    trace<T>(value: T): T;
+    /**
+     * Wrap a callback so calls trace `this` and arguments to this context.
+     *
+     * @param callback — the function to wrap.
+     * @returns a proxy delegating to `callback` with traced values.
+     */
+    bind<T extends Function>(callback: T): T;
+}
+//# sourceMappingURL=reflect.d.ts.map