tnega 0.1.0 → 0.3.0

package/dist/types/packages/cli/src/profile-file.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin } from "../../core/src/index.js";
+import type { AgentRuntimeOptions } from './commands.js';
+import type { AgentProfile } from './profile.js';
+import { bootAgentRuntime, generalAgentProfile } from './profile.js';
+/** A serializable reference to a bundle: a built-in name, or an explicit bundler module. */
+export type ProfileBundleRef = {
+    plugin?: undefined;
+} | {
+    plugin: Plugin;
+} | {
+    module: string;
+} | {
+    name: string;
+};
+export interface LoadableAgentProfile {
+    name: string;
+    bundles: readonly ProfileBundleRef[];
+    options?: Record<string, unknown>;
+}
+export declare function profileDir(): string;
+export declare function profileFile(name: string): string;
+export declare function resolveProfileFile(nameOrFile: string): string;
+export declare function readAgentProfile(nameOrFile: string): Promise<AgentProfile>;
+export declare function ensureProfileDir(): Promise<string>;
+export declare function bootAgentRuntimeFromFile(base: Parameters<typeof bootAgentRuntime>[0], nameOrFile: string, overlay?: Parameters<typeof bootAgentRuntime>[2]): Promise<AgentRuntimeOptions>;
+export { generalAgentProfile };

package/dist/types/packages/cli/src/profile.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "../../core/src/index.js";
+import type { AgentRuntimeOptions } from './commands.js';
+export interface AgentProfile {
+    name: string;
+    bundles: readonly Plugin[];
+    options?: Omit<AgentRuntimeOptions, 'cwd' | 'sessionFile' | 'plugins'>;
+}
+export declare const generalAgentProfile: AgentProfile;
+export declare function bootAgentRuntime(base: Pick<AgentRuntimeOptions, 'cwd' | 'sessionFile'>, profile?: AgentProfile, overlay?: Omit<AgentRuntimeOptions, 'cwd' | 'sessionFile'>): AgentRuntimeOptions;

package/dist/types/packages/cli/src/server.d.ts

@@ -0,0 +1,14 @@
+export interface WebServerOptions {
+    port?: number;
+    host?: string;
+    webRoot?: string;
+    configFile?: string;
+    /** Run sessions through resident durable-inbox agents (auto mode). */
+    resident?: boolean;
+}
+export interface WebServer {
+    url: string;
+    port: number;
+    close: () => Promise<void>;
+}
+export declare function startWebServer(options?: WebServerOptions): Promise<WebServer>;

package/dist/types/packages/cli/src/store.d.ts

@@ -0,0 +1,60 @@
+import { type ContextUsage, type AgentType, type ModelMessage, type SessionMode } from "../../session/src/index.js";
+export interface SessionMetaPayload {
+    title: string;
+    workspace: string;
+    createdAt: number;
+    parentSessionId?: string;
+    forkedAtMessageId?: string;
+    agentType?: AgentType;
+    mode?: SessionMode;
+}
+export interface SessionSummary extends SessionMetaPayload {
+    id: string;
+    updatedAt: number;
+    eventCount: number;
+}
+export interface CreateSessionOptions {
+    title?: string;
+    createdAt?: number;
+    parentSessionId?: string;
+    forkedAtMessageId?: string;
+    agentType?: AgentType;
+    mode?: SessionMode;
+}
+export interface SessionMetaPatch {
+    title?: string;
+    agentType?: AgentType;
+    mode?: SessionMode;
+}
+export declare function sessionDir(workspace: string): string;
+export declare function sessionFile(workspace: string, id: string): string;
+export declare function isSessionId(value: string): boolean;
+export declare function ensureSessionDir(workspace: string): Promise<string>;
+export declare function createSession(workspace: string, options?: CreateSessionOptions): Promise<SessionSummary>;
+export declare function listSessions(workspace: string): Promise<SessionSummary[]>;
+export declare function readSessionSummary(workspace: string, id: string): Promise<SessionSummary>;
+export declare function setSessionTitle(workspace: string, id: string, title: string): Promise<SessionSummary>;
+export declare function patchSessionMeta(workspace: string, id: string, patch: SessionMetaPatch): Promise<SessionSummary>;
+export declare function forkSession(workspace: string, id: string, options?: {
+    title?: string;
+    messageId?: string;
+}): Promise<SessionSummary>;
+export declare function truncateSessionAt(workspace: string, id: string, messageId: string): Promise<SessionSummary>;
+export declare function readSessionMessages(workspace: string, id: string): Promise<ModelMessage[]>;
+export declare function estimateContextUsage(workspace: string, id: string): Promise<ContextUsage>;
+export interface CompactSessionOptions {
+    keep?: number;
+    keepTokens?: number;
+    checkpointMessages?: readonly ModelMessage[];
+    summary?: string;
+    tokensBefore?: number;
+}
+export interface SessionCompactPreparation {
+    prefixMessages: ModelMessage[];
+    previousSummary: string | undefined;
+    tokensBefore: number;
+}
+export declare function prepareSessionCompact(workspace: string, id: string, keepTokens: number): Promise<SessionCompactPreparation>;
+export declare function compactSession(workspace: string, id: string, options?: CompactSessionOptions): Promise<SessionSummary>;
+export declare function deleteSession(workspace: string, id: string): Promise<void>;
+export declare function ensureWorkspace(value: string): Promise<string>;

package/dist/types/packages/cli/src/yaml.d.ts

@@ -0,0 +1 @@
+export declare function parseYaml(text: string): Record<string, unknown>;

package/dist/types/packages/coding-agent/src/codingAgent.d.ts

@@ -0,0 +1,25 @@
+import type { Plugin } from "../../core/src/index.js";
+import { type LLMAdapter } from "../../agent/src/index.js";
+import type { ModelMessage, SessionMode } from "../../session/src/index.js";
+import { type SlashCommandResult } from './slash.js';
+import type { CodingSurvey, Plan, SlashCommand, SlashSuggestion } from './types.js';
+export interface CodingAgentOptions {
+    cwd: string;
+    mode?: SessionMode;
+    setMode?: (mode: SessionMode) => void | Promise<void>;
+    skills?: boolean;
+    mcp?: boolean;
+    planTools?: boolean;
+    registerAgent?: boolean;
+    systemPrompt?: string;
+    planPrompt?: string;
+}
+export interface CodingService {
+    generatePlan(adapter: LLMAdapter, messages: readonly ModelMessage[], signal?: AbortSignal): Promise<Plan>;
+    commands(): SlashCommand[];
+    runCommand(name: string, args: string[]): Promise<SlashCommandResult>;
+    suggestCommand(name: string): Promise<SlashSuggestion[]>;
+    survey(): CodingSurvey;
+}
+export declare const CODING_SYSTEM_PROMPT = "You are Tnega, a coding agent running in a workspace session.\n\nYou work iteratively in the user's repository:\n- Inspect the workspace before editing when the task is unclear.\n- Make small, reviewable changes and verify them with tests or commands when appropriate.\n- Report exact file paths and command output in your final answer.\n- Keep the user's existing code conventions and do not rewrite unrelated code.\n\nWhen a plan is present, follow it and keep every item's status updated with the plan tools.";
+export declare function createCodingAgentPlugin(options: CodingAgentOptions): Plugin;

package/dist/types/packages/coding-agent/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './plan.js';
+export * from './skills.js';
+export * from './mcp.js';
+export * from './slash.js';
+export * from './codingAgent.js';

package/dist/types/packages/coding-agent/src/mcp.d.ts

@@ -0,0 +1,24 @@
+import type { ToolDefinition } from "../../tools/src/index.js";
+export interface McpServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    stderr?: 'inherit' | 'pipe' | 'ignore';
+}
+export interface McpConfig {
+    mcpServers?: Record<string, McpServerConfig>;
+}
+export interface McpSurvey {
+    name: string;
+    status: 'connected' | 'failed';
+    toolCount: number;
+    error?: string;
+}
+export interface McpRuntime {
+    surveys: McpSurvey[];
+    tools: ToolDefinition[];
+    dispose(): Promise<void>;
+}
+export declare function loadMcpConfig(cwd: string): Promise<McpConfig>;
+export declare function connectMcpServers(cwd: string, onTool?: (server: string, tool: ToolDefinition) => void): Promise<McpRuntime>;

package/dist/types/packages/coding-agent/src/plan.d.ts

@@ -0,0 +1,13 @@
+import type { ModelMessage } from "../../session/src/index.js";
+import type { LLMAdapter } from "../../agent/src/index.js";
+import type { Plan, PlanStatus } from './types.js';
+export declare class PlanGenerationError extends Error {
+    name: string;
+}
+export declare const PLAN_GENERATION_MAX_RETRIES = 2;
+export declare const PLAN_GENERATION_PROMPT = "You are a planning assistant for a coding agent.\nAnalyze the user request and produce a concise, ordered implementation plan.\n\nRespond with ONLY a JSON object in this exact shape:\n{\n  \"summary\": \"one or two sentence overview of the goal\",\n  \"items\": [\n    {\n      \"title\": \"short actionable step\",\n      \"detail\": \"optional one-line detail, can be omitted\"\n    }\n  ]\n}\n\nRules:\n- Split the work into 2-8 concrete steps with clear checkable outcomes.\n- Keep titles short and imperative.\n- Do not include markdown fences, prose, or anything outside the JSON object.";
+export declare function planCorrectionPrompt(previous: string): string;
+export declare function parsePlanResponse(raw: string): Plan;
+export declare function planToContext(plan: Plan): string;
+export declare function isValidPlanStatus(value: unknown): value is PlanStatus;
+export declare function generatePlan(adapter: LLMAdapter, messages: readonly ModelMessage[], signal?: AbortSignal, prompt?: string): Promise<Plan>;

package/dist/types/packages/coding-agent/src/skills.d.ts

@@ -0,0 +1,12 @@
+import type { ToolDefinition } from "../../tools/src/index.js";
+export interface SkillEntry {
+    name: string;
+    path: string;
+    description: string;
+}
+export declare function skillsDir(cwd: string): string;
+export declare function ensureSkillsDir(cwd: string): Promise<string>;
+export declare function listSkills(cwd: string): Promise<SkillEntry[]>;
+export declare function readSkill(cwd: string, name: string): Promise<string>;
+export declare function skillTool(cwd: string): Promise<ToolDefinition>;
+export declare function skillReadTool(cwd: string): Promise<ToolDefinition>;

package/dist/types/packages/coding-agent/src/slash.d.ts

@@ -0,0 +1,28 @@
+import type { ToolDefinition } from "../../tools/src/index.js";
+import type { SessionMode } from "../../session/src/index.js";
+import { type SkillEntry } from './skills.js';
+import type { McpSurvey } from './mcp.js';
+import type { SlashCommand, SlashCommandResult, SlashSuggestion } from './types.js';
+export type { SlashCommandResult, SlashSuggestion } from './types.js';
+export interface SlashContext {
+    tools: readonly ToolDefinition[];
+    cwd: string;
+    mode?: SessionMode;
+    setMode?: (mode: SessionMode) => void | Promise<void>;
+    skills?: SkillEntry[];
+    mcp?: {
+        surveys: McpSurvey[];
+        tools: readonly ToolDefinition[];
+    };
+}
+export type SlashHandler = (args: string[], context: SlashContext) => SlashCommandResult | Promise<SlashCommandResult>;
+export type SlashSuggester = (context: SlashContext) => SlashSuggestion[] | Promise<SlashSuggestion[]>;
+export declare class SlashRegistry {
+    private _commands;
+    register(name: string, description: string, handler: SlashHandler, suggest?: SlashSuggester): void;
+    list(): SlashCommand[];
+    run(name: string, args: string[], context: SlashContext): Promise<SlashCommandResult>;
+    suggest(name: string, context: SlashContext): Promise<SlashSuggestion[]>;
+    has(name: string): boolean;
+}
+export declare function createSlashRegistry(): SlashRegistry;

package/dist/types/packages/coding-agent/src/types.d.ts

@@ -0,0 +1,41 @@
+import type { AgentType, SessionMode } from "../../session/src/index.js";
+export type PlanStatus = 'pending' | 'done' | 'failed';
+export interface PlanItem {
+    id: string;
+    title: string;
+    status: PlanStatus;
+    detail?: string;
+}
+export interface Plan {
+    summary?: string;
+    items: PlanItem[];
+    status: 'pending' | 'running' | 'done' | 'failed';
+}
+export interface SlashCommand {
+    name: string;
+    description: string;
+}
+export interface SlashSuggestion {
+    command: string;
+    args: string[];
+    label: string;
+    detail?: string;
+}
+export type SlashCommandResult = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'json';
+    value: unknown;
+};
+export interface CodingSurvey {
+    agentType: AgentType;
+    mode: SessionMode;
+    planTools: number;
+    skillsEnabled: boolean;
+    skills: number;
+    mcpEnabled: boolean;
+    mcpServers: number;
+    mcpTools: number;
+}
+export { type AgentType, type SessionMode };

package/dist/types/packages/core/src/context.d.ts

@@ -0,0 +1,28 @@
+import { EventsService } from './events.js';
+import './fiber.js';
+import { Logger, LoggerService } from './logger.js';
+import { ReflectService } from './reflect.js';
+import { RegistryService } from './registry.js';
+import { symbols, type Any, type Dict } from './utils.js';
+export interface Context {
+    root: this;
+    baseUrl?: string | undefined;
+    events: EventsService;
+    logger: LoggerService & ((name?: string) => Logger);
+    reflect: ReflectService;
+    registry: RegistryService;
+}
+export declare class Context {
+    [symbols.isolate]: Dict<symbol | undefined>;
+    [symbols.intercept]: Dict<any>;
+    static readonly effect: symbol;
+    static readonly filter: symbol;
+    static readonly isolate: symbol;
+    static readonly intercept: symbol;
+    static readonly marker: unique symbol;
+    static is(value: Any): value is Context;
+    constructor();
+    extend(meta?: Dict): this;
+    isolate(name: string, label?: symbol): this;
+    intercept(name: string, config: Any): this;
+}

package/dist/types/packages/core/src/events.d.ts

@@ -0,0 +1,57 @@
+import { Context } from './context.js';
+import { type Any, type AnyFunction } from './utils.js';
+declare module './context.js' {
+    interface Context {
+        on(name: string, listener: AnyFunction, options?: boolean | EventOptions): () => Any;
+        once(name: string, listener: AnyFunction, options?: boolean | EventOptions): () => Any;
+        emit(name: string, ...args: Any[]): void;
+        emit(thisArg: object, name: string, ...args: Any[]): void;
+        parallel(name: string, ...args: Any[]): Promise<void>;
+        parallel(thisArg: object, name: string, ...args: Any[]): Promise<void>;
+        serial(name: string, ...args: Any[]): Promise<void>;
+        serial(thisArg: object, name: string, ...args: Any[]): Promise<void>;
+        bail(name: string, ...args: Any[]): Any;
+        bail(thisArg: object, name: string, ...args: Any[]): Any;
+        waterfall(name: string, ...args: Any[]): Any;
+        waterfall(thisArg: object, name: string, ...args: Any[]): Any;
+        waterfallAsync(name: string, ...args: Any[]): Promise<Any>;
+        waterfallAsync(thisArg: object, name: string, ...args: Any[]): Promise<Any>;
+    }
+}
+export declare function isBailed(value: Any): boolean;
+export type DispatchMode = 'emit' | 'parallel' | 'serial' | 'bail' | 'waterfall' | 'waterfallAsync';
+export interface EventOptions {
+    prepend?: boolean;
+    global?: boolean;
+}
+export interface Hook extends EventOptions {
+    ctx: Context;
+    callback: AnyFunction;
+}
+export declare class EventsService {
+    private ctx;
+    _hooks: Record<string, Hook[]>;
+    constructor(ctx: Context);
+    private _resolve;
+    dispatch(type: string, args: Any[]): AnyFunction[];
+    parallel(...args: Any[]): Promise<void>;
+    emit(...args: Any[]): void;
+    serial(...args: Any[]): Promise<any>;
+    bail(...args: Any[]): any;
+    waterfall(...args: Any[]): any;
+    waterfallAsync(...args: Any[]): Promise<any>;
+    register(label: string, hooks: Hook[], callback: AnyFunction, options: EventOptions): Any;
+    unregister(hooks: Hook[], callback: AnyFunction): true | undefined;
+    on(name: string, listener: AnyFunction, options?: boolean | EventOptions): Any;
+    once(name: string, listener: AnyFunction, options?: boolean | EventOptions): any;
+}
+export interface Events {
+    'internal/plugin'(this: Any): void;
+    'internal/status'(this: Any, oldValue: Any): void;
+    'internal/service'(this: Context, name: string, value: Any): void;
+    'internal/update'(this: Any, config: Any, noSave: boolean, next: AnyFunction): void;
+    'internal/get'(this: Context, name: string, error: Error, next: AnyFunction): Any;
+    'internal/set'(this: Context, name: string, value: Any, error: Error, next: AnyFunction): boolean;
+    'internal/listener'(this: Context, name: string, listener: AnyFunction, options: EventOptions): Any;
+    'internal/dispatch'(mode: DispatchMode, name: string, args: Any[], thisArg: Any): void;
+}

package/dist/types/packages/core/src/fiber.d.ts

@@ -0,0 +1,79 @@
+import type { Context } from './context.js';
+import type { PluginRuntime } from './registry.js';
+import type { Impl } from './reflect.js';
+import { DisposableList, type Any, type AnyFunction, type Dict } from './utils.js';
+declare module './context.js' {
+    interface Context extends Pick<Fiber, 'effect'> {
+        fiber: Fiber;
+    }
+}
+export declare class ValidationError extends TypeError {
+    name: string;
+    constructor(issues: readonly Any[]);
+}
+export declare function resolveConfig(runtime: PluginRuntime, config: Any): any;
+export type Disposable = () => Any;
+export type SyncEffect = Disposable | Iterable<Disposable> | null | undefined;
+export type AsyncEffect = Promise<Disposable> | AsyncIterable<Disposable> | null | undefined;
+export type Effect = SyncEffect | AsyncEffect;
+interface AsyncDisposable extends PromiseLike<() => Promise<void>> {
+    (): Any;
+}
+export interface EffectMeta {
+    label: string;
+    children: EffectMeta[];
+}
+export declare const enum FiberState {
+    PENDING = 0,
+    LOADING = 1,
+    ACTIVE = 2,
+    FAILED = 3,
+    DISPOSED = 4,
+    UNLOADING = 5
+}
+export declare const CordisErrorCode: {
+    readonly INACTIVE_EFFECT: "cannot create effect on inactive context";
+};
+export type CordisErrorCode = keyof typeof CordisErrorCode;
+export declare class CordisError extends Error {
+    code: CordisErrorCode;
+    constructor(code: CordisErrorCode, message?: string);
+}
+export declare class Fiber {
+    parent: Context;
+    inject: Dict<Any>;
+    runtime: PluginRuntime | null;
+    uid: number | null;
+    readonly ctx: Context;
+    config: Any;
+    state: FiberState;
+    readonly dispose: () => Promise<void>;
+    store: Dict<Impl> | undefined;
+    inertia: Promise<void> | undefined;
+    readonly _hooks: Dict<DisposableList<AnyFunction>>;
+    readonly _disposables: DisposableList<Disposable>;
+    protected context: Context;
+    private _error;
+    private _runner;
+    private _store;
+    private _restarting;
+    constructor(parent: Context, config: Any, inject: Dict<Any>, runtime: PluginRuntime | null, getOuterStack: () => string[]);
+    get name(): string;
+    assertActive(): void;
+    private _execute;
+    effect(execute: () => SyncEffect, label?: string): Disposable;
+    effect(execute: () => Effect, label?: string): AsyncDisposable;
+    getEffects(): EffectMeta[];
+    private _getState;
+    private _updateState;
+    _checkImpl(name: string): boolean | undefined;
+    _refresh(): void;
+    private _setEpoch;
+    private _reload;
+    private _unload;
+    await(): Promise<this>;
+    restart(): Promise<undefined>;
+    private _runRestart;
+    update(config: Any, noSave?: boolean): void;
+}
+export {};

package/dist/types/packages/core/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from './context.js';
+export * from './events.js';
+export * from './fiber.js';
+export * from './invariant.js';
+export * from './logger.js';
+export * from './reflect.js';
+export * from './registry.js';
+export * from './service.js';
+export * from './utils.js';
+export declare const name = "index.js";

package/dist/types/packages/core/src/invariant.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Invariant companion support.
+ *
+ * Layered defense, mirroring the DSH "each package ships a `./invariant`"
+ * discipline: every package that owns durable or live relationships exports a
+ * set of checks that continuously assert cross-event / cross-data invariants
+ * (open/close pairing, monotonic sequence, ownership). The checks are pure
+ * over the data they observe, so they can run at any time: on load, on each
+ * commit, or on demand during tests and debugging.
+ */
+export interface InvariantContext {
+    /**
+     * The durable events observed so far. A check runs over whatever slice the
+     * caller supplies (the full log, a single appended event, …).
+     */
+    events: readonly unknown[];
+    [key: string]: unknown;
+}
+/** A check returns a list of violated descriptions; an empty list means pass. */
+export type InvariantCheck = (context: InvariantContext) => readonly string[] | Promise<readonly string[]>;
+export interface InvariantDefinition {
+    /** Stable, package-scoped name, e.g. `session/open-lifecycle`. */
+    name: string;
+    /** When this check does not apply, explain why in one line. */
+    describe(): string;
+    check: InvariantCheck;
+}
+export declare class InvariantRegistry {
+    private _checks;
+    register(definition: InvariantDefinition): () => void;
+    has(name: string): boolean;
+    list(): readonly InvariantDefinition[];
+    runAll(context: InvariantContext): Promise<readonly string[]>;
+}
+export declare class InvariantViolationError extends Error {
+    readonly violations: readonly string[];
+    name: string;
+    constructor(violations: readonly string[]);
+}
+/** Fail-fast helper: throws when any registered invariant reports a violation. */
+export declare function assertInvariants(violations: readonly string[]): void;
+export declare const invariant: {
+    name: string;
+    apply: (ctx: import("./context.js").Context) => () => void;
+};

package/dist/types/packages/core/src/logger.d.ts

@@ -0,0 +1,48 @@
+import type { Context } from './context.js';
+import { symbols, type Any } from './utils.js';
+export type LoggerType = 'error' | 'info' | 'warn' | 'debug';
+export type LoggerMethod = (format: Any, ...param: Any[]) => void;
+export interface Message {
+    sn: number;
+    ts: number;
+    name: string;
+    type: LoggerType;
+    args: Any[];
+}
+export interface Exporter {
+    level?: number;
+    export(message: Message): void;
+}
+export interface LoggerOptions {
+    name: string;
+    level?: number;
+}
+export interface LoggerService {
+    (name?: string): Logger;
+}
+export declare class Logger {
+    private service;
+    name: string;
+    level: number | undefined;
+    error: LoggerMethod;
+    info: LoggerMethod;
+    warn: LoggerMethod;
+    debug: LoggerMethod;
+    constructor(options: LoggerOptions, service: LoggerService);
+    private _method;
+}
+export declare class LoggerService {
+    [symbols.invoke]: (name?: string) => Logger;
+    buffer: Message[];
+    ctx: Context;
+    _snMessage: number;
+    _snExporter: number;
+    exporters: Map<number, Exporter>;
+    constructor(ctx: Context);
+    exporter(exporter: Exporter): import("./fiber.js").Disposable;
+    _log(message: Omit<Message, 'sn' | 'ts'>): void;
+    error(...args: Any[]): any;
+    info(...args: Any[]): any;
+    warn(...args: Any[]): any;
+    debug(...args: Any[]): any;
+}

package/dist/types/packages/core/src/reflect.d.ts

@@ -0,0 +1,42 @@
+import type { Context } from './context.js';
+import { type Any, type AnyFunction, type Dict } from './utils.js';
+declare module './context.js' {
+    interface Context {
+        get(name: string, strict?: boolean): Any;
+        set(name: string, value: Any): void;
+        provide(name: string, value?: Any, check?: () => boolean): () => Any;
+        accessor(name: string, options: Omit<AccessorProperty, 'type'>): () => Any;
+        mixin(source: Any, mixins: string[] | Dict<string>): void;
+    }
+}
+export interface ServiceProperty {
+    type: 'service';
+}
+export interface AccessorProperty {
+    type: 'accessor';
+    get: (this: Context, receiver: Any, error: Error) => Any;
+    set?: (this: Context, value: Any, receiver: Any, error: Error) => boolean;
+}
+export type ReflectProperty = ServiceProperty | AccessorProperty;
+export interface Impl {
+    name: string;
+    fiber: Any;
+    value?: Any;
+    check?: () => boolean;
+}
+export declare class ReflectService {
+    ctx: Context;
+    static handler: ProxyHandler<Context>;
+    store: Dict<Impl, symbol>;
+    props: Dict<ReflectProperty>;
+    constructor(ctx: Context);
+    get(name: string, strict?: boolean): any;
+    _getImpl(name: string, strict?: boolean): any;
+    set(name: string, value: Any): boolean;
+    provide(name: string, value?: Any, check?: () => boolean): import("./fiber.js").Disposable;
+    notify(names: string[], filter?: (ctx: Context, name: string) => boolean): any[];
+    accessor(name: string, options: Omit<AccessorProperty, 'type'>): import("./fiber.js").Disposable;
+    mixin(source: Any, mixins: string[] | Dict<string>): import("./fiber.js").Disposable;
+    trace<T>(value: T): T;
+    bind<T extends AnyFunction>(callback: T): T;
+}

package/dist/types/packages/core/src/registry.d.ts

@@ -0,0 +1,54 @@
+import type { Context } from './context.js';
+import { Fiber } from './fiber.js';
+import { DisposableList, type Any, type AnyFunction, type Dict } from './utils.js';
+declare module './context.js' {
+    interface Context {
+        inject(deps: Inject, callback: FunctionPlugin): Fiber & PromiseLike<Fiber>;
+        plugin<P extends Plugin>(plugin: P, ...args: Any[]): Fiber & PromiseLike<Fiber>;
+    }
+}
+export type Inject = string[] | Dict<Any>;
+export type InjectKey = string & keyof Context;
+export declare function Inject(name: string, config?: Any): (value: Any, decorator: Any) => void;
+export declare function resolveInject(inject: Inject | null | undefined, result?: Dict): Dict;
+export type Plugin = FunctionPlugin | ConstructorPlugin | ObjectPlugin;
+export interface PluginBase {
+    name?: string;
+    Config?: Any;
+    inject?: Inject;
+    provide?: string | string[];
+    intercept?: Dict<boolean>;
+}
+export interface FunctionPlugin extends PluginBase {
+    (ctx: Context, config: Any): Any;
+}
+export interface ConstructorPlugin extends PluginBase {
+    new (ctx: Context, config: Any): Any;
+}
+export interface ObjectPlugin extends PluginBase {
+    apply(ctx: Context, config: Any): Any;
+}
+export interface PluginRuntime {
+    name?: string;
+    fibers: DisposableList<Fiber>;
+    callback: Any;
+    Config?: Any;
+}
+export declare class RegistryService {
+    ctx: Context;
+    private _counter;
+    private _internal;
+    constructor(ctx: Context);
+    get counter(): number;
+    get size(): number;
+    resolve(plugin: Plugin): AnyFunction | undefined;
+    get(plugin: Plugin): PluginRuntime | undefined;
+    has(plugin: Plugin): boolean;
+    delete(plugin: Plugin): PluginRuntime | undefined;
+    keys(): MapIterator<AnyFunction>;
+    values(): MapIterator<PluginRuntime>;
+    entries(): MapIterator<[AnyFunction, PluginRuntime]>;
+    forEach(callback: (value: PluginRuntime, key: AnyFunction) => void): void;
+    inject(inject: Inject, callback: FunctionPlugin): Fiber & PromiseLike<Fiber>;
+    plugin(plugin: Plugin, config?: Any, getOuterStack?: () => string[]): Fiber & PromiseLike<Fiber>;
+}