@zhin.js/core 1.3.3 → 1.3.5

package/lib/plugin-runtime/im/contracts.js

@@ -0,0 +1,55 @@
+const componentCallBrand = 'zhin.component-call/1';
+const rawContentBrand = 'zhin.raw-content/1';
+export function component(name, props) {
+    if (!name.trim())
+        throw new TypeError('Component name cannot be empty');
+    return Object.freeze({ $content: componentCallBrand, name, props });
+}
+export function raw(payload) {
+    return Object.freeze({ $content: rawContentBrand, payload });
+}
+export function isComponentCall(value) {
+    return !Array.isArray(value)
+        && typeof value === 'object'
+        && value !== null
+        && '$content' in value
+        && value.$content === componentCallBrand;
+}
+export function isRawContent(value) {
+    return !Array.isArray(value)
+        && typeof value === 'object'
+        && value !== null
+        && '$content' in value
+        && value.$content === rawContentBrand;
+}
+export class Message {
+    adapter;
+    target;
+    content;
+    generation;
+    id;
+    sender;
+    metadata;
+    constructor(adapter, target, content, generation, reply, id, sender, metadata = Object.freeze({})) {
+        this.adapter = adapter;
+        this.target = target;
+        this.content = content;
+        this.generation = generation;
+        this.id = id;
+        this.sender = sender;
+        this.metadata = metadata;
+        this.$reply = (content) => reply(content);
+        this.$replyFrom = (requester, content) => reply(content, requester);
+        Object.freeze(this);
+    }
+    $reply;
+    $replyFrom;
+}
+export function createOutboundEnvelope(request, initialPayload) {
+    let payload = initialPayload;
+    return Object.freeze({
+        ...request,
+        get payload() { return payload; },
+        replace(next) { payload = next; },
+    });
+}

package/lib/plugin-runtime/im/im-runtime.d.ts

@@ -0,0 +1,70 @@
+import { Scope, type PluginId, type RuntimeSnapshot, type SnapshotStore } from '@zhin.js/plugin-runtime';
+import { Message, type ChannelParent, type IncomingMessage, type MessageDispatchResult, type MessageGateway, type SendRequest } from './contracts.js';
+import { OutboundRenderer } from './outbound-renderer.js';
+export declare const messageGatewayToken: import("@zhin.js/plugin-runtime").Token<MessageGateway>;
+export interface ImRuntimeOptions {
+    readonly commandPrefix?: string;
+    readonly renderer?: OutboundRenderer;
+}
+export declare class ImRuntime implements MessageGateway {
+    #private;
+    constructor(options?: ImRuntimeOptions);
+    attach(snapshots: SnapshotStore): void;
+    /**
+     * Optional Host AI / fallback path after Command miss (or non-prefixed text).
+     * Return true when the message was handled (reply already sent).
+     * `requester` is the Adapter Endpoint owner (for CapabilityIngress inheritance).
+     */
+    setUnmatchedHandler(handler: (message: Message, snapshot: RuntimeSnapshot, requester: PluginId) => Promise<boolean>): void;
+    install(resources: Scope): void;
+    receive(input: IncomingMessage): Promise<MessageDispatchResult>;
+    send(request: SendRequest): Promise<unknown>;
+    /** Console `endpoint.list` — empty until Adapter Feature projection is ready. */
+    listEndpoints(): readonly {
+        readonly name: string;
+        readonly adapter: string;
+        readonly connected: boolean;
+        readonly status: 'online' | 'offline';
+        readonly phase: 'pending' | 'starting' | 'online' | 'failed' | 'unconfigured';
+    }[];
+    getEndpoint(adapter: string, endpointId: string): {
+        readonly name: string;
+        readonly adapter: string;
+        readonly connected: boolean;
+        readonly status: 'online' | 'offline';
+        readonly phase: 'pending' | 'starting' | 'online' | 'failed' | 'unconfigured';
+    } | null;
+    sendEndpointMessage(input: {
+        readonly adapter: string;
+        readonly endpointId: string;
+        readonly channelId: string;
+        readonly channelType: string;
+        readonly content: unknown;
+        readonly parent?: ChannelParent;
+    }): Promise<{
+        messageId: string;
+    }>;
+    /** Activity-feedback: add a message reaction when the live Endpoint supports it. */
+    addEndpointReaction(input: {
+        readonly adapter: string;
+        readonly endpointId: string;
+        readonly messageId: string;
+        readonly emoji: string;
+        readonly sceneType?: string;
+        readonly channelId?: string;
+    }): Promise<string | null>;
+    removeEndpointReaction(input: {
+        readonly adapter: string;
+        readonly endpointId: string;
+        readonly messageId: string;
+        readonly reactionId: string;
+    }): Promise<void>;
+    /** Activity-feedback autoRemove: recall a previously sent status message. */
+    recallEndpointMessage(input: {
+        readonly adapter: string;
+        readonly endpointId: string;
+        readonly messageId: string;
+    }): Promise<void>;
+    /** Console endpoint 社交/群管 RPC：解析 live Endpoint 实例（无则 null）。 */
+    getLiveEndpoint(adapter: string, endpointId: string): unknown | null;
+}

package/lib/plugin-runtime/im/im-runtime.js

@@ -0,0 +1,299 @@
+import { createToken, htmlRendererToken, } from '@zhin.js/plugin-runtime';
+import { adapterFeatureId, isAdapterIndex } from '@zhin.js/adapter';
+import { isMiddlewareIndex, middlewareFeatureId } from '@zhin.js/middleware';
+import { Message, createOutboundEnvelope, } from './contracts.js';
+import { MessageDispatcher } from './message-dispatcher.js';
+import { OutboundRenderer } from './outbound-renderer.js';
+import { normalizeOutboundPayload } from './outbound-segments.js';
+export const messageGatewayToken = createToken('zhin.im.message-gateway');
+export class ImRuntime {
+    #dispatcher;
+    #renderer;
+    #snapshots;
+    #unmatchedHandler;
+    constructor(options = {}) {
+        this.#dispatcher = new MessageDispatcher(options.commandPrefix);
+        this.#renderer = options.renderer ?? new OutboundRenderer();
+    }
+    attach(snapshots) {
+        if (this.#snapshots && this.#snapshots !== snapshots) {
+            throw new Error('ImRuntime is already attached to another Root');
+        }
+        this.#snapshots = snapshots;
+    }
+    /**
+     * Optional Host AI / fallback path after Command miss (or non-prefixed text).
+     * Return true when the message was handled (reply already sent).
+     * `requester` is the Adapter Endpoint owner (for CapabilityIngress inheritance).
+     */
+    setUnmatchedHandler(handler) {
+        this.#unmatchedHandler = handler;
+    }
+    install(resources) {
+        resources.provide(messageGatewayToken, this);
+    }
+    async receive(input) {
+        const lease = this.#acquire();
+        let active = true;
+        try {
+            const requester = requireAdapters(lease.value).owner(input.adapter);
+            const message = new Message(input.adapter, input.target, input.content, lease.value.generation, (content, replyRequester = requester) => {
+                if (!active)
+                    throw new Error('Message reply scope has ended');
+                return this.#sendWithSnapshot({
+                    adapter: input.adapter,
+                    target: input.target,
+                    requester: replyRequester,
+                    content,
+                }, lease.value);
+            }, input.id, input.sender, Object.freeze({ ...input.metadata }));
+            let result = Object.freeze({ matched: false });
+            await runMiddleware(lease.value, message, async () => {
+                result = await this.#dispatcher.dispatch(message, lease.value);
+                if (!result.matched && this.#unmatchedHandler) {
+                    const handled = await this.#unmatchedHandler(message, lease.value, requester);
+                    if (handled) {
+                        result = Object.freeze({ matched: true, command: 'ai', owner: requester });
+                    }
+                }
+            }, 'inbound');
+            return result;
+        }
+        finally {
+            active = false;
+            lease.release();
+        }
+    }
+    async send(request) {
+        const lease = this.#acquire();
+        try {
+            return await this.#sendWithSnapshot(request, lease.value);
+        }
+        finally {
+            lease.release();
+        }
+    }
+    /** Console `endpoint.list` — empty until Adapter Feature projection is ready. */
+    listEndpoints() {
+        try {
+            const lease = this.#acquire();
+            try {
+                return requireAdapters(lease.value).describe().map((row) => Object.freeze({
+                    name: row.name,
+                    // adapter 列显示平台类型（owner 包名去 scope/adapter- 前缀），不是 slot localName
+                    adapter: adapterTypeName(lease.value.tree.get(row.owner)?.packageName) ?? row.name,
+                    connected: row.connected,
+                    status: row.status,
+                    phase: row.phase,
+                }));
+            }
+            finally {
+                lease.release();
+            }
+        }
+        catch {
+            return Object.freeze([]);
+        }
+    }
+    getEndpoint(adapter, endpointId) {
+        try {
+            const lease = this.#acquire();
+            try {
+                const index = requireAdapters(lease.value);
+                const id = index.resolve(adapter, endpointId);
+                if (!id)
+                    return null;
+                const row = index.describe().find((item) => item.id === id);
+                if (!row)
+                    return null;
+                return Object.freeze({
+                    name: row.name,
+                    adapter: row.name,
+                    connected: row.connected,
+                    status: row.status,
+                    phase: row.phase,
+                });
+            }
+            finally {
+                lease.release();
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    async sendEndpointMessage(input) {
+        const lease = this.#acquire();
+        try {
+            const index = requireAdapters(lease.value);
+            const capabilityId = index.resolve(input.adapter, input.endpointId);
+            if (!capabilityId)
+                throw new Error('endpoint not found');
+            const target = composeSendTarget(input.channelType, input.channelId);
+            const content = normalizeConsoleContent(input.content);
+            const result = await this.#sendWithSnapshot({
+                adapter: capabilityId,
+                target,
+                requester: index.owner(capabilityId),
+                content,
+                ...(input.parent ? { parent: input.parent } : {}),
+            }, lease.value);
+            return { messageId: result == null ? '' : String(result) };
+        }
+        finally {
+            lease.release();
+        }
+    }
+    /** Activity-feedback: add a message reaction when the live Endpoint supports it. */
+    async addEndpointReaction(input) {
+        const endpoint = this.#liveEndpoint(input.adapter, input.endpointId);
+        if (!endpoint)
+            return null;
+        if (typeof endpoint.addReaction === 'function') {
+            return endpoint.addReaction(input.messageId, input.emoji, {
+                sceneType: input.sceneType,
+                channelId: input.channelId,
+            });
+        }
+        if (typeof endpoint.$addReaction === 'function') {
+            return endpoint.$addReaction(input.messageId, input.emoji, {
+                sceneType: input.sceneType,
+                channelId: input.channelId,
+            });
+        }
+        return null;
+    }
+    async removeEndpointReaction(input) {
+        const endpoint = this.#liveEndpoint(input.adapter, input.endpointId);
+        if (!endpoint)
+            return;
+        if (typeof endpoint.removeReaction === 'function') {
+            await endpoint.removeReaction(input.messageId, input.reactionId);
+            return;
+        }
+        if (typeof endpoint.$removeReaction === 'function') {
+            await endpoint.$removeReaction(input.messageId, input.reactionId);
+        }
+    }
+    /** Activity-feedback autoRemove: recall a previously sent status message. */
+    async recallEndpointMessage(input) {
+        const endpoint = this.#liveEndpoint(input.adapter, input.endpointId);
+        if (!endpoint)
+            return;
+        if (typeof endpoint.recallMessage === 'function') {
+            await endpoint.recallMessage(input.messageId);
+            return;
+        }
+        if (typeof endpoint.$recallMessage === 'function') {
+            await endpoint.$recallMessage(input.messageId);
+        }
+    }
+    #liveEndpoint(adapter, endpointId) {
+        try {
+            const lease = this.#acquire();
+            try {
+                const endpoint = requireAdapters(lease.value).instance(adapter, endpointId);
+                return endpoint ?? null;
+            }
+            finally {
+                lease.release();
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Console endpoint 社交/群管 RPC：解析 live Endpoint 实例（无则 null）。 */
+    getLiveEndpoint(adapter, endpointId) {
+        return this.#liveEndpoint(adapter, endpointId);
+    }
+    async #sendWithSnapshot(request, snapshot) {
+        const rendered = await this.#renderer.render(request.content, request.requester, snapshot);
+        // 单段对象 / html 段在此归一为适配器可消费的 wire 段数组；
+        // sandbox 适配器（控制台 UI）直接消费 html 段，跳过规范化。
+        const payload = isDirectHtmlConsumer(snapshot, request.adapter)
+            ? rendered
+            : await normalizeOutboundPayload(rendered, resolveHtmlRenderer(snapshot));
+        const envelope = createOutboundEnvelope({
+            adapter: request.adapter,
+            target: request.target,
+            requester: request.requester,
+            generation: snapshot.generation,
+            ...(request.parent ? { parent: request.parent } : {}),
+        }, payload);
+        let result;
+        await runMiddleware(snapshot, envelope, async () => {
+            result = await requireAdapters(snapshot).send(request.adapter, {
+                target: request.target,
+                payload: envelope.payload,
+                ...(request.parent ? { parent: request.parent } : {}),
+            });
+        }, 'outbound');
+        return result;
+    }
+    #acquire() {
+        if (!this.#snapshots)
+            throw new Error('ImRuntime is not attached to a Root');
+        return this.#snapshots.acquire();
+    }
+}
+function requireAdapters(snapshot) {
+    const projection = snapshot.projections.get(adapterFeatureId);
+    if (!isAdapterIndex(projection)) {
+        throw new Error('Adapter Feature projection is not installed');
+    }
+    return projection;
+}
+/** Root resources 上的可选 html-renderer Host（未安装时降级为文本）。 */
+function resolveHtmlRenderer(snapshot) {
+    const host = snapshot.resources.get(snapshot.root)?.get(htmlRendererToken.id);
+    return host && typeof host.render === 'function'
+        ? host
+        : undefined;
+}
+/**
+ * Sandbox（控制台 UI）按设计直接消费 html 段，不做 html→image/text 规范化。
+ * 通过 adapter 能力 slot 的 owner 包名判断平台类型。
+ */
+function isDirectHtmlConsumer(snapshot, adapter) {
+    const owner = snapshot.capabilities.get(adapter)?.owner;
+    return adapterTypeName(snapshot.tree.get(owner)?.packageName) === 'sandbox';
+}
+/**
+ * Build Adapter send target. If channelId already carries a scene prefix
+ * (`private:uid` / `group:gid`), do not double-prefix.
+ */
+function composeSendTarget(channelType, channelId) {
+    const id = channelId.trim();
+    if (!id)
+        return channelType || '';
+    if (/^(private|group|channel|direct|c2c|temp):/iu.test(id))
+        return id;
+    return channelType ? `${channelType}:${id}` : id;
+}
+/** `@zhin.js/adapter-icqq` → `icqq`；非 adapter 包名原样返回。 */
+function adapterTypeName(packageName) {
+    if (!packageName)
+        return undefined;
+    return packageName.replace(/^@[^/]+\/adapter-/, '');
+}
+function middleware(snapshot) {
+    const projection = snapshot.projections.get(middlewareFeatureId);
+    return isMiddlewareIndex(projection) ? projection : undefined;
+}
+async function runMiddleware(snapshot, input, terminal, target) {
+    const index = middleware(snapshot);
+    if (index)
+        await index.run(input, terminal, target);
+    else
+        await terminal();
+}
+function normalizeConsoleContent(content) {
+    if (typeof content === 'string')
+        return content;
+    // Array content passes through untouched, matching the legacy console RPC
+    // contract (element arrays must not be stringified to '[object Object]').
+    if (Array.isArray(content))
+        return content;
+    return String(content);
+}

package/lib/plugin-runtime/im/index.d.ts

@@ -0,0 +1,5 @@
+export * from './contracts.js';
+export * from './im-runtime.js';
+export * from './message-dispatcher.js';
+export * from './outbound-renderer.js';
+export * from './outbound-segments.js';

package/lib/plugin-runtime/im/index.js

@@ -0,0 +1,5 @@
+export * from './contracts.js';
+export * from './im-runtime.js';
+export * from './message-dispatcher.js';
+export * from './outbound-renderer.js';
+export * from './outbound-segments.js';

package/lib/plugin-runtime/im/message-dispatcher.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeSnapshot } from '@zhin.js/plugin-runtime';
+import type { Message, MessageDispatchResult } from './contracts.js';
+export declare class MessageDispatcher {
+    private readonly prefix;
+    constructor(prefix?: string);
+    dispatch(message: Message, snapshot: RuntimeSnapshot): Promise<MessageDispatchResult>;
+}

package/lib/plugin-runtime/im/message-dispatcher.js

@@ -0,0 +1,26 @@
+import { commandFeatureId, isCommandIndex } from '@zhin.js/command';
+export class MessageDispatcher {
+    prefix;
+    constructor(prefix = '/') {
+        this.prefix = prefix;
+        if (!prefix)
+            throw new TypeError('Command prefix cannot be empty');
+    }
+    async dispatch(message, snapshot) {
+        if (!message.content.startsWith(this.prefix))
+            return Object.freeze({ matched: false });
+        const input = message.content.slice(this.prefix.length).trim();
+        if (!input)
+            return Object.freeze({ matched: false });
+        const commands = snapshot.projections.get(commandFeatureId);
+        if (!isCommandIndex(commands))
+            return Object.freeze({ matched: false });
+        const result = await commands.dispatch(input, message);
+        if (result.matched && result.value !== undefined) {
+            if (!result.owner)
+                throw new Error('Matched Command is missing its owner');
+            await message.$replyFrom(result.owner, result.value);
+        }
+        return result;
+    }
+}

package/lib/plugin-runtime/im/outbound-renderer.d.ts

@@ -0,0 +1,6 @@
+import type { PluginId, RuntimeSnapshot } from '@zhin.js/plugin-runtime';
+import { type SendContent } from './contracts.js';
+export declare class OutboundRenderer {
+    #private;
+    render(content: SendContent, requester: PluginId, snapshot: RuntimeSnapshot): Promise<unknown>;
+}

package/lib/plugin-runtime/im/outbound-renderer.js

@@ -0,0 +1,31 @@
+import { componentFeatureId, isComponentIndex, } from '@zhin.js/component';
+import { isComponentCall, isRawContent, } from './contracts.js';
+const maxComponentDepth = 32;
+export class OutboundRenderer {
+    async render(content, requester, snapshot) {
+        return this.#render(content, requester, snapshot, 0);
+    }
+    async #render(content, requester, snapshot, depth) {
+        if (depth > maxComponentDepth)
+            throw new Error('Component render depth exceeded 32');
+        if (typeof content === 'string')
+            return content;
+        if (Array.isArray(content)) {
+            return Promise.all(content.map((item) => this.#render(item, requester, snapshot, depth)));
+        }
+        if (isRawContent(content))
+            return content.payload;
+        if (isComponentCall(content)) {
+            const rendered = await requireComponents(snapshot).render(requester, content.name, content.props);
+            return this.#render(rendered, requester, snapshot, depth + 1);
+        }
+        throw new TypeError('Unsupported SendContent');
+    }
+}
+function requireComponents(snapshot) {
+    const projection = snapshot.projections.get(componentFeatureId);
+    if (!isComponentIndex(projection)) {
+        throw new Error('Component Feature projection is not installed');
+    }
+    return projection;
+}

package/lib/plugin-runtime/im/outbound-segments.d.ts

@@ -0,0 +1,22 @@
+import type { HtmlRendererHost } from '@zhin.js/plugin-runtime';
+/**
+ * Outbound payload normalization for the Plugin Runtime IM pipeline.
+ *
+ * `raw()` payloads reach adapters as-is; adapters only understand wire
+ * segments (`{ type, data }` arrays). A single segment object (non-array)
+ * would otherwise fall through to `String(payload)` → '[object Object]'.
+ * `html` segments additionally need a Host renderer: image when
+ * `@zhin.js/html-renderer` is installed, plain-text fallback otherwise.
+ */
+export interface OutboundSegment {
+    readonly type: string;
+    readonly data?: Record<string, unknown>;
+}
+export declare function isOutboundSegment(value: unknown): value is OutboundSegment;
+/**
+ * Normalize a rendered outbound payload to wire segments:
+ * - segment arrays stay arrays (html segments converted per element);
+ * - a single segment object is wrapped into a one-element array;
+ * - anything else (plain strings, legacy `{ text }` shorthands) passes through.
+ */
+export declare function normalizeOutboundPayload(payload: unknown, renderer?: HtmlRendererHost): Promise<unknown>;

package/lib/plugin-runtime/im/outbound-segments.js

@@ -0,0 +1,59 @@
+import { htmlToFallbackText } from '../../built/html-to-text.js';
+const DEFAULT_CARD_WIDTH = 540;
+const DEFAULT_CARD_FILENAME = 'card.png';
+export function isOutboundSegment(value) {
+    return typeof value === 'object'
+        && value !== null
+        && !Array.isArray(value)
+        && typeof value.type === 'string';
+}
+/**
+ * Normalize a rendered outbound payload to wire segments:
+ * - segment arrays stay arrays (html segments converted per element);
+ * - a single segment object is wrapped into a one-element array;
+ * - anything else (plain strings, legacy `{ text }` shorthands) passes through.
+ */
+export async function normalizeOutboundPayload(payload, renderer) {
+    if (Array.isArray(payload)) {
+        return Promise.all(payload.map((item) => normalizeOutboundSegment(item, renderer)));
+    }
+    if (isOutboundSegment(payload)) {
+        return [await normalizeOutboundSegment(payload, renderer)];
+    }
+    return payload;
+}
+async function normalizeOutboundSegment(segment, renderer) {
+    if (!isOutboundSegment(segment) || segment.type !== 'html')
+        return segment;
+    const data = segment.data ?? {};
+    const html = typeof data.html === 'string' ? data.html : '';
+    if (html && renderer) {
+        try {
+            const result = await renderer.render(html, {
+                width: typeof data.width === 'number' ? data.width : DEFAULT_CARD_WIDTH,
+                format: 'png',
+                ...(typeof data.backgroundColor === 'string'
+                    ? { backgroundColor: data.backgroundColor }
+                    : {}),
+            });
+            if (result.format === 'png' && result.data && typeof result.data === 'object') {
+                return {
+                    type: 'image',
+                    data: {
+                        base64: Buffer.from(result.data).toString('base64'),
+                        name: typeof data.fileName === 'string' ? data.fileName : DEFAULT_CARD_FILENAME,
+                    },
+                };
+            }
+        }
+        catch {
+            // 渲染失败 → 文本降级
+        }
+    }
+    return { type: 'text', data: { text: htmlSegmentFallbackText(data, html) } };
+}
+function htmlSegmentFallbackText(data, html) {
+    if (typeof data.text === 'string' && data.text.length > 0)
+        return data.text;
+    return html ? htmlToFallbackText(html) : '';
+}

package/lib/plugin.d.ts

@@ -6,12 +6,10 @@
  * - 生命周期事件类型安全（Plugin.Lifecycle）
  * - 中间件系统、适配器管理、useContext 等
  */
-import type { PluginManifest } from "./types.js";
+import { MessageMiddleware, RegisteredAdapter, MaybePromise, ArrayItem, SendOptions, MessageSendPayload, type PluginManifest } from './types.js';
 import type { InteractiveHandler } from "./built/interactive-segments/types.js";
-import { MessageMiddleware, RegisteredAdapter, MaybePromise, ArrayItem, SendOptions, MessageSendPayload } from "./types.js";
 import { Adapter, Adapters } from "./adapter.js";
-import { PluginBase, PluginBaseLifecycle } from "@zhin.js/kernel";
-import type { PluginLike } from "@zhin.js/kernel";
+import { PluginBase, PluginBaseLifecycle, type PluginLike } from '@zhin.js/kernel';
 export { getPlugin } from "./plugin-context.js";
 export { storage, getCurrentFile } from "./plugin-context.js";
 export { setHostRootPlugin, getHostRootPlugin } from "./host-plugin-registry.js";

package/lib/plugin.js

@@ -13,8 +13,7 @@ import { formatCompact } from "@zhin.js/logger";
 import { compose, remove, resolveEntry } from "./utils.js";
 import { ensureInteractiveMiddleware, registerInteractiveHandler as registerInteractiveHandlerCore, } from "./built/interactive-segments/handlers.js";
 import { Adapter } from "./adapter.js";
-import { Feature } from "@zhin.js/kernel";
-import { PluginBase, resolvePluginResolveDir as _resolvePluginResolveDir, pluginCreateRequire as _pluginCreateRequire, getFileHash, watchFile, registerExtension, unregisterExtensions, installExtensionProxy, } from "@zhin.js/kernel";
+import { Feature, PluginBase, resolvePluginResolveDir as _resolvePluginResolveDir, pluginCreateRequire as _pluginCreateRequire, getFileHash, watchFile, registerExtension, unregisterExtensions, installExtensionProxy } from '@zhin.js/kernel';
 import { storage, getCurrentFile } from "./plugin-context.js";
 // Re-export getPlugin from plugin-context for backward compatibility
 export { getPlugin } from "./plugin-context.js";
@@ -121,15 +120,20 @@ export class Plugin extends PluginBase {
     get name() {
         if (this.#cachedName)
             return this.#cachedName;
-        this.#cachedName = path
+        let name = path
             .relative(process.cwd(), this.filePath)
             .replace(/\?t=\d+$/, "")
             .replace(/\\/g, "/")
             .replace(/\/index\.(js|ts)x?$/, "")
-            .replace(/\/(lib|src|dist)$/, "")
-            .replace(/.*\/node_modules\//, "")
-            .replace(/.*\//, "")
-            .replace(/\.(js|ts)x?$/, "");
+            .replace(/\/(lib|src|dist)$/, "");
+        const nodeModulesIndex = name.indexOf("node_modules/");
+        if (nodeModulesIndex !== -1)
+            name = name.slice(nodeModulesIndex + "node_modules/".length);
+        const slash = name.lastIndexOf("/");
+        if (slash !== -1)
+            name = name.slice(slash + 1);
+        name = name.replace(/\.(js|ts)x?$/, "");
+        this.#cachedName = name;
         return this.#cachedName;
     }
     /**
@@ -426,7 +430,7 @@ export class Plugin extends PluginBase {
             installExtensionProxy(Plugin.prototype);
             for (const [name, fn] of Object.entries(context.extensions)) {
                 if (typeof fn === 'function') {
-                    registerExtension(name, fn); // eslint-disable-line @typescript-eslint/no-explicit-any
+                    registerExtension(name, fn);
                 }
             }
         }