@zhin.js/plugin-runtime 1.1.16 → 1.1.17

package/lib/database-host.d.ts

@@ -44,6 +44,11 @@ export interface DatabaseHostTable {
     readonly name: string;
     readonly columns?: Readonly<Record<string, unknown>>;
 }
+/** Explicit, additive upgrades applied before SQL models become available. */
+export interface DatabaseTableOptions {
+    /** Names from this table's definition. Existing columns and data remain untouched. */
+    readonly addColumns?: readonly string[];
+}
 export interface DatabaseHostSelectResult {
     readonly rows: readonly unknown[];
     readonly total: number;
@@ -83,7 +88,7 @@ export interface DatabaseHost {
     readonly dialect: string;
     readonly started: boolean;
     /** Register a table schema before `start` (column defs match `@zhin.js/database`). */
-    define(name: string, definition: Record<string, unknown>): void;
+    define(name: string, definition: Record<string, unknown>, options?: DatabaseTableOptions): void;
     /** Names of tables registered via `define` (Console `db:tables`). */
     tables(): readonly string[];
     models: {
@@ -129,7 +134,7 @@ export declare class PluginDatabaseHost extends OwnerScopedResourceHost {
     get [generationAdmissionSource](): readonly GenerationAdmissionGate[];
     get dialect(): string;
     get started(): boolean;
-    define(name: string, definition: Record<string, unknown>): void;
+    define(name: string, definition: Record<string, unknown>, options?: DatabaseTableOptions): void;
     tables(): readonly string[];
     transaction<T>(callback: (transaction: DatabaseHostTransaction) => Promise<T>): Promise<T>;
 }

package/lib/database-host.js

@@ -54,8 +54,10 @@ export class PluginDatabaseHost extends OwnerScopedResourceHost {
     get started() {
         return this.#host.started;
     }
-    define(name, definition) {
-        this.#operation.setup(() => this.#host.define(this.qualify(name), definition));
+    define(name, definition, options) {
+        this.#operation.setup(() => options === undefined
+            ? this.#host.define(this.qualify(name), definition)
+            : this.#host.define(this.qualify(name), definition, options));
     }
     tables() {
         return this.#operation.setup(() => Object.freeze(this.#host.tables().flatMap((name) => {

package/lib/i18n.d.ts

@@ -0,0 +1,24 @@
+import type { DeliveryTarget } from './delivery-target.js';
+/** Supported display languages. Time zone and command identities are independent. */
+export type Locale = 'zh-CN' | 'en';
+export declare const DEFAULT_LOCALE: Locale;
+export declare const SUPPORTED_LOCALES: readonly ["zh-CN", "en"];
+export declare function isLocale(value: unknown): value is Locale;
+/** Resolve an absent display preference; configuration writes validate with isLocale. */
+export declare function resolveLocale(value: unknown): Locale;
+/** Immutable project language, projected with the operation's generation. */
+export declare const projectLocaleToken: import("./token.js").Token<Locale>;
+/** Root-owned preferences; identity never comes from display names or profile text. */
+export interface UserLocalePreferences {
+    get(endpoint: DeliveryTarget['endpoint'], senderId: string): Promise<Locale | undefined>;
+    set(endpoint: DeliveryTarget['endpoint'], senderId: string, locale: Locale): Promise<void>;
+}
+export declare const userLocalePreferencesToken: import("./token.js").Token<UserLocalePreferences>;
+export type MessageCatalog = Readonly<Record<string, Readonly<Record<Locale, string>>>>;
+export type MessageValues = Readonly<Record<string, string | number>>;
+/**
+ * A package-owned, complete bilingual catalog. No global language or registration.
+ * Placeholder substitution is one pass: user text cannot become another template.
+ * Values remain plain text; HTML/JSX escaping belongs to the existing renderer.
+ */
+export declare function createMessages<const T extends MessageCatalog>(catalog: T): (locale: Locale | undefined, key: keyof T & string, values?: MessageValues) => string;

package/lib/i18n.js

@@ -0,0 +1,38 @@
+import { createToken } from './token.js';
+export const DEFAULT_LOCALE = 'zh-CN';
+export const SUPPORTED_LOCALES = Object.freeze(['zh-CN', 'en']);
+export function isLocale(value) {
+    return value === 'zh-CN' || value === 'en';
+}
+/** Resolve an absent display preference; configuration writes validate with isLocale. */
+export function resolveLocale(value) {
+    return isLocale(value) ? value : DEFAULT_LOCALE;
+}
+/** Immutable project language, projected with the operation's generation. */
+export const projectLocaleToken = createToken('zhin.project-locale');
+export const userLocalePreferencesToken = createToken('zhin.user-locale-preferences');
+/**
+ * A package-owned, complete bilingual catalog. No global language or registration.
+ * Placeholder substitution is one pass: user text cannot become another template.
+ * Values remain plain text; HTML/JSX escaping belongs to the existing renderer.
+ */
+export function createMessages(catalog) {
+    const entries = Object.freeze(Object.fromEntries(Object.entries(catalog).map(([key, value]) => {
+        const keys = (text) => [...new Set([...text.matchAll(/\{([a-zA-Z][\w]*)\}/gu)].map(match => match[1]))].sort();
+        if (typeof value['zh-CN'] !== 'string' || typeof value.en !== 'string'
+            || JSON.stringify(keys(value['zh-CN'])) !== JSON.stringify(keys(value.en))) {
+            throw new TypeError(`Invalid bilingual message catalog entry: ${key}`);
+        }
+        return [key, Object.freeze({ ...value })];
+    })));
+    return (locale, key, values = {}) => {
+        const entry = entries[key];
+        if (!Object.hasOwn(entries, key) || !entry)
+            throw new TypeError(`Unknown message catalog entry: ${key}`);
+        return entry[resolveLocale(locale)].replace(/\{([a-zA-Z][\w]*)\}/gu, (_match, name) => {
+            if (!Object.hasOwn(values, name))
+                throw new TypeError(`Missing message value: ${name}`);
+            return String(values[name]);
+        });
+    };
+}

package/lib/index.d.ts

@@ -12,6 +12,7 @@ export * from './handoff.js';
 export * from './plugin.js';
 /** @public Root configuration contract shared by Runtime and composition tooling. */
 export * from './plugin-configuration.js';
+export * from './i18n.js';
 export * from './root-config-file.js';
 export * from './root-config-document.js';
 /** @internal Runtime 内部：RootRuntime / RootController。 */
@@ -39,3 +40,4 @@ export * from './system-log.js';
 export * from './plugin-verification.js';
 export * from './plugin-tasks.js';
 export * from './task-storage.js';
+export * from './plugin-console-rpc.js';

package/lib/index.js

@@ -12,6 +12,7 @@ export * from './handoff.js';
 export * from './plugin.js';
 /** @public Root configuration contract shared by Runtime and composition tooling. */
 export * from './plugin-configuration.js';
+export * from './i18n.js';
 export * from './root-config-file.js';
 export * from './root-config-document.js';
 /** @internal Runtime 内部：RootRuntime / RootController。 */
@@ -39,3 +40,4 @@ export * from './system-log.js';
 export * from './plugin-verification.js';
 export * from './plugin-tasks.js';
 export * from './task-storage.js';
+export * from './plugin-console-rpc.js';

package/lib/outbound-host.d.ts

@@ -1,5 +1,6 @@
 import type { DeliveryTarget } from './delivery-target.js';
 import type { PluginId } from './identity.js';
+import type { Locale } from './i18n.js';
 import { generationAdmissionBinder, generationAdmissionSource, type GenerationAdmissionGate } from './admission.js';
 /**
  * 未锚定 endpoint 的会话地址（结构对齐 `@zhin.js/im-contract` 的
@@ -21,6 +22,8 @@ export interface OutboundConversation {
  * `sendEndpointMessage` (resolve adapter/endpoint → AdapterIndex.send).
  */
 export interface OutboundSendInput {
+    /** Language captured by the originating operation or persisted task. */
+    readonly locale?: Locale;
     readonly adapter: string;
     readonly endpointKey: string;
     readonly conversation: OutboundConversation;
@@ -73,7 +76,9 @@ export interface OutboundMessage {
 }
 export interface OutboundHost {
     /** Sends to persisted exact identities, rejecting stale addresses instead of aliasing another bot. */
-    sendTarget?(target: DeliveryTarget, content: unknown): Promise<string | null>;
+    sendTarget?(target: DeliveryTarget, content: unknown, options?: Readonly<{
+        locale?: Locale;
+    }>): Promise<string | null>;
     /** Runs related operations against one IM Runtime snapshot captured at ingress. */
     runWithView?<T>(operation: () => Promise<T>): Promise<T>;
     /** Exact operations declared by one live Endpoint. */
@@ -95,7 +100,9 @@ export interface OutboundHost {
 }
 /** Root-only process port: requester is supplied by the owner-bound facade. */
 export interface OutboundRootHost extends Omit<OutboundHost, 'sendTarget'> {
-    sendTarget?(target: DeliveryTarget, content: unknown, requester: PluginId): Promise<string | null>;
+    sendTarget?(target: DeliveryTarget, content: unknown, requester: PluginId, options?: Readonly<{
+        locale?: Locale;
+    }>): Promise<string | null>;
 }
 /** Preserve the sending plugin as requester, independent of the destination endpoint owner. */
 export declare class PluginOutboundHost implements OutboundHost {

package/lib/outbound-host.js

@@ -28,7 +28,9 @@ export class PluginOutboundHost {
         const recall = host.recall?.bind(host);
         const edit = host.edit?.bind(host);
         const typing = host.typing?.bind(host);
-        this.sendTarget = sendTarget ? async (target, content) => this.#run(() => sendTarget(target, content, this.#owner)) : undefined;
+        this.sendTarget = sendTarget ? async (target, content, options) => this.#run(() => options
+            ? sendTarget(target, content, this.#owner, options)
+            : sendTarget(target, content, this.#owner)) : undefined;
         this.runWithView = runWithView ? (operation) => this.#run(() => runWithView(operation)) : undefined;
         this.capabilities = capabilities ? (input) => this.#run(() => capabilities(input)) : undefined;
         this.addReaction = addReaction ? (input) => this.#run(() => addReaction(input)) : undefined;

package/lib/plugin-console-rpc.d.ts

@@ -0,0 +1,86 @@
+import { type GenerationAdmissionSource } from './admission.js';
+import type { JsonValue } from './persistent-state.js';
+/**
+ * Plugin-registered Console RPC (zhinjs/zhin#970).
+ *
+ * A plugin publishes one {@link PluginConsoleRpc} through {@link pluginConsoleRpcToken}. The Host
+ * exposes it on the existing Console RPC envelope as `plugin.<pluginId>.status` and
+ * `plugin.<pluginId>.<action>`, where `<pluginId>` is the owner PluginId (for example
+ * `root/typesafe`). No WebSocket, no new HTTP route, and no generic config writes.
+ *
+ * Authorization follows the Console Page the method is bound to (`page`): the caller must
+ * satisfy that page's `requiredPermissions` / `requiredRoles`, plus the method's own. The full
+ * (admin) token may call everything. Other tokens (`user` / `demo`) may call a method when they
+ * hold every required permission and role. An action is open to them only when it declares its
+ * own `requiredPermissions` / `requiredRoles` / `anyOfPermissions` (the page's requirements apply on
+ * top, but never grant an action by themselves); an unguarded `status` needs `demo: true`.
+ * `anyOfPermissions` is satisfied by holding at least one of the listed permissions (for a new
+ * permission that coexists with an older one, e.g. `ops:approve` beside `tool_approvals:resolve`).
+ */
+export type PluginConsoleRpcJson = JsonValue;
+export type PluginConsoleRpcInput = Readonly<Record<string, JsonValue>>;
+export interface PluginConsoleRpcCall {
+    /** Aborted when the Host request times out. Long work must observe it. */
+    readonly signal: AbortSignal;
+}
+export interface PluginConsoleRpcMethod<TInput = PluginConsoleRpcInput> {
+    /** Local name of a Page owned by the same plugin (`pages/<page>/index.tsx`). Its access rules apply. */
+    readonly page?: string;
+    /** Extra permissions on top of the page's own requirements. */
+    readonly requiredPermissions?: readonly string[];
+    /** Extra roles on top of the page's own requirements. */
+    readonly requiredRoles?: readonly string[];
+    /**
+     * The caller must also hold at least one of these (in addition to every `requiredPermissions`).
+     * Counts as the method's own requirement for actions.
+     */
+    readonly anyOfPermissions?: readonly string[];
+    /**
+     * Return a small, user-facing JSON shape. Never return raw log records, prompts, chat lines,
+     * secrets or exception text: the Console shows this to ordinary users.
+     */
+    handler(input: TInput, call: PluginConsoleRpcCall): JsonValue | Promise<JsonValue>;
+}
+export interface PluginConsoleRpcStatus extends PluginConsoleRpcMethod<PluginConsoleRpcInput> {
+    /** Allow the demo-scope Console token to read this status. Default `false`. */
+    readonly demo?: boolean;
+}
+export interface PluginConsoleRpcDefinition {
+    /** Read-only status for the plugin's Console page(s): `plugin.<pluginId>.status`. */
+    readonly status?: PluginConsoleRpcStatus;
+    /**
+     * Extra read-only views beside `status`: `plugin.<pluginId>.<name>`. Same access rules as
+     * `status`; use them when one plugin backs several pages with different permissions.
+     */
+    readonly queries?: Readonly<Record<string, PluginConsoleRpcStatus>>;
+    /**
+     * Limited, named actions: `plugin.<pluginId>.<name>`. Non-admin tokens may run one only when the
+     * action declares its own requirements and the token holds them (plus the page's); otherwise
+     * admin-only.
+     */
+    readonly actions?: Readonly<Record<string, PluginConsoleRpcMethod>>;
+}
+export interface NormalizedPluginConsoleRpcMethod {
+    readonly page?: string;
+    readonly requiredPermissions: readonly string[];
+    readonly requiredRoles: readonly string[];
+    /** Empty when the method has no either-of requirement. */
+    readonly anyOfPermissions: readonly string[];
+    readonly demo: boolean;
+    /** `status` and `queries` are read-only; actions are not. */
+    readonly readOnly: boolean;
+    readonly handler: PluginConsoleRpcMethod['handler'];
+}
+/** Value published under {@link pluginConsoleRpcToken}; create it with {@link definePluginConsoleRpc}. */
+export interface PluginConsoleRpc extends GenerationAdmissionSource {
+    readonly methods: ReadonlyMap<string, NormalizedPluginConsoleRpcMethod>;
+}
+/** Safe, user-facing failure. `message` is shown in the Console; never put raw errors in it. */
+export declare class PluginConsoleRpcError extends Error {
+    readonly code: 'invalid_input' | 'conflict' | 'not_found' | 'unsupported' | 'unavailable';
+    constructor(code: PluginConsoleRpcError['code'], message: string);
+}
+export declare const pluginConsoleRpcToken: import("./token.js").Token<PluginConsoleRpc>;
+export declare const PLUGIN_CONSOLE_RPC_STATUS = "status";
+/** Validates and freezes a plugin's Console RPC surface. Throws on invalid names at setup time. */
+export declare function definePluginConsoleRpc(definition: PluginConsoleRpcDefinition): PluginConsoleRpc;

package/lib/plugin-console-rpc.js

@@ -0,0 +1,69 @@
+import { createGenerationAdmissionGate, generationAdmissionSource, } from './admission.js';
+import { createToken } from './token.js';
+/** Safe, user-facing failure. `message` is shown in the Console; never put raw errors in it. */
+export class PluginConsoleRpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'PluginConsoleRpcError';
+        this.code = code;
+    }
+}
+export const pluginConsoleRpcToken = createToken('zhin.plugin-console-rpc', 'Plugin-owned Console status and limited actions, called through the authenticated Console RPC envelope');
+export const PLUGIN_CONSOLE_RPC_STATUS = 'status';
+const methodNamePattern = /^[a-z][a-z0-9-]{0,63}$/u;
+const pageNamePattern = /^[a-z0-9][a-z0-9-]*$/u;
+/** Validates and freezes a plugin's Console RPC surface. Throws on invalid names at setup time. */
+export function definePluginConsoleRpc(definition) {
+    if (!definition || typeof definition !== 'object')
+        throw new TypeError('Plugin Console RPC definition must be an object');
+    const methods = new Map();
+    if (definition.status !== undefined) {
+        methods.set(PLUGIN_CONSOLE_RPC_STATUS, normalizeMethod('status', definition.status, definition.status.demo === true, true));
+    }
+    for (const [kind, entries] of [['query', definition.queries], ['action', definition.actions]]) {
+        for (const [name, method] of Object.entries(entries ?? {})) {
+            if (!methodNamePattern.test(name))
+                throw new TypeError(`Invalid plugin Console RPC ${kind} name: ${name}`);
+            if (name === PLUGIN_CONSOLE_RPC_STATUS)
+                throw new TypeError('"status" is reserved; declare it as definition.status');
+            if (methods.has(name))
+                throw new TypeError(`Duplicate plugin Console RPC method: ${name}`);
+            const readOnly = kind === 'query';
+            methods.set(name, normalizeMethod(name, method, readOnly && method.demo === true, readOnly));
+        }
+    }
+    if (methods.size === 0)
+        throw new TypeError('Plugin Console RPC must declare status or at least one action');
+    const gate = createGenerationAdmissionGate();
+    const gates = Object.freeze([gate]);
+    return Object.freeze({
+        methods: methods,
+        get [generationAdmissionSource]() { return gates; },
+    });
+}
+function normalizeMethod(name, method, demo, readOnly) {
+    if (!method || typeof method.handler !== 'function') {
+        throw new TypeError(`Plugin Console RPC ${name} must have a handler`);
+    }
+    if (method.page !== undefined && (typeof method.page !== 'string' || !pageNamePattern.test(method.page))) {
+        throw new TypeError(`Plugin Console RPC ${name} has an invalid page name`);
+    }
+    return Object.freeze({
+        ...(method.page === undefined ? {} : { page: method.page }),
+        requiredPermissions: stringList(method.requiredPermissions, `${name} requiredPermissions`),
+        requiredRoles: stringList(method.requiredRoles, `${name} requiredRoles`),
+        anyOfPermissions: stringList(method.anyOfPermissions, `${name} anyOfPermissions`),
+        demo,
+        readOnly,
+        handler: method.handler,
+    });
+}
+function stringList(value, label) {
+    if (value === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(value) || !value.every((item) => typeof item === 'string' && item.trim())) {
+        throw new TypeError(`Plugin Console RPC ${label} must be non-empty strings`);
+    }
+    return Object.freeze([...new Set(value)].sort());
+}

package/lib/plugin-tasks.d.ts

@@ -1,6 +1,7 @@
 import type { DeliveryTarget } from './delivery-target.js';
 import type { JsonValue } from './persistent-state.js';
 import type { GenerationAdmissionSource } from './admission.js';
+import type { Locale } from './i18n.js';
 export type PluginTaskState = 'scheduled' | 'paused' | 'running' | 'unknown' | 'succeeded' | 'failed' | 'cancelled';
 export type PluginTaskAction = 'pause' | 'resume' | 'cancel' | 'update';
 /** Business task facts. Chat-user tasks are deliberately outside this administrator port. */
@@ -31,19 +32,28 @@ export interface PluginTaskMutationReceipt {
     readonly operation: 'create' | PluginTaskAction;
 }
 export interface PluginTaskMutation {
+    /** Display language only; excluded from mutation identity and notification settings. */
+    readonly locale?: Locale;
     /** Client-created operation UUID, retained for reconciliation after a lost response. */
     readonly requestId: string;
     readonly expectedRevision: string;
 }
 /** Optional plugin-owned task service, resolved from the current generation's owner scope. */
 export interface PluginTaskProvider extends GenerationAdmissionSource {
+    readonly i18n?: Readonly<Partial<Record<Locale, Readonly<{
+        title?: string;
+        description?: string;
+        effects?: readonly string[];
+    }>>>>;
     readonly title: string;
     readonly description: string;
     /** JSON Schema for this provider's creation/update parameters, never a Console-specific form. */
     readonly schema: Readonly<Record<string, JsonValue>>;
     /** Discloses future external effects before the operator creates a task. */
     readonly effects: readonly string[];
-    read(): Promise<PluginTaskSnapshot>;
+    read(options?: Readonly<{
+        locale?: Locale;
+    }>): Promise<PluginTaskSnapshot>;
     create(input: PluginTaskMutation & Readonly<{
         target: DeliveryTarget;
         parameters: Readonly<Record<string, JsonValue>>;

package/lib/plugin-verification.d.ts

@@ -1,14 +1,19 @@
+import type { Locale } from './i18n.js';
 /** A deliberate business check. Effects must describe every write or external action. */
 export interface PluginVerificationCheck {
     readonly id: string;
     readonly title: string;
+    readonly titleI18n?: Readonly<Partial<Record<Locale, string>>>;
     readonly effects: readonly string[];
+    readonly effectsI18n?: Readonly<Partial<Record<Locale, readonly string[]>>>;
     readonly scope: 'local' | 'platform';
 }
 export interface PluginVerificationOutcome {
     readonly status: 'passed' | 'failed';
     readonly summary: string;
+    readonly summaryI18n?: Readonly<Partial<Record<Locale, string>>>;
     readonly evidence: readonly string[];
+    readonly evidenceI18n?: Readonly<Partial<Record<Locale, readonly string[]>>>;
 }
 /** Plugin-owned optional verification, distinct from generation publication/readiness. */
 export interface PluginVerificationHost {

package/lib/relational-state.d.ts

@@ -8,6 +8,8 @@ export interface RelationalStateCodec {
         readonly definition: Record<string, unknown>;
     };
     readonly tables: Readonly<Record<string, Record<string, unknown>>>;
+    /** Explicit additions for an already persisted relational table. */
+    readonly addColumns?: Readonly<Record<string, readonly string[]>>;
     encode(value: JsonValue): {
         header: Record<string, unknown>;
         rows: Record<string, readonly Record<string, unknown>[]>;

package/lib/relational-state.js

@@ -22,8 +22,14 @@ export function createRelationalStateStore(database, codecs) {
             storage_present: { type: 'boolean', nullable: false },
             storage_expires_at: { type: 'bigint', nullable: true },
         });
-        for (const [name, definition] of Object.entries(codec.tables))
-            database.define(name, definition);
+        for (const name of Object.keys(codec.addColumns ?? {})) {
+            if (!Object.hasOwn(codec.tables, name))
+                throw new TypeError(`Unknown relational migration table: ${name}`);
+        }
+        for (const [name, definition] of Object.entries(codec.tables)) {
+            const columns = codec.addColumns?.[name];
+            database.define(name, definition, columns ? { addColumns: columns } : undefined);
+        }
     }
     const migrated = new Set();
     const writeRows = async (transaction, codec, rows) => {

package/lib/root-config-document.js

@@ -36,6 +36,10 @@ function setValue(document, path, value) {
     for (const [index, segment] of path.slice(0, -1).entries()) {
         const existing = readChild(target, segment, path.slice(0, index + 1));
         if (existing === undefined) {
+            // Inline guard (in addition to assertPath) so the write is visibly safe.
+            if (segment === '__proto__' || segment === 'constructor' || segment === 'prototype') {
+                throw unsafeSegment(segment);
+            }
             const created = {};
             target[segment] = created;
             target = created;
@@ -59,7 +63,11 @@ function removeValue(document, path) {
         target.splice(arrayIndex(segment, target, path), 1);
         return;
     }
-    delete target[segment];
+    if (segment === '__proto__' || segment === 'constructor' || segment === 'prototype') {
+        throw unsafeSegment(segment);
+    }
+    if (Object.hasOwn(target, segment))
+        delete target[segment];
 }
 function cloneDocument(value) {
     const document = structuredClone(value);
@@ -71,13 +79,18 @@ function cloneDocument(value) {
 function readChild(container, segment, path) {
     if (Array.isArray(container))
         return container[arrayIndex(segment, container, path)];
-    return container[segment];
+    // Only own properties count: inherited members (toString, hasOwnProperty, ...)
+    // must never be traversed into or treated as existing config values.
+    return Object.hasOwn(container, segment) ? container[segment] : undefined;
 }
 function writeChild(container, segment, value, path) {
     if (Array.isArray(container)) {
         container[arrayIndex(segment, container, path)] = value;
         return;
     }
+    if (segment === '__proto__' || segment === 'constructor' || segment === 'prototype') {
+        throw unsafeSegment(segment);
+    }
     container[segment] = value;
 }
 function arrayIndex(segment, container, path) {
@@ -99,10 +112,13 @@ function requireContainer(value, path) {
 function assertPath(path) {
     for (const segment of path) {
         if (!segment || segment === '__proto__' || segment === 'prototype' || segment === 'constructor') {
-            throw new ConfigPatchPathError(`Unsafe config path segment: ${segment || '<empty>'}`);
+            throw unsafeSegment(segment);
         }
     }
 }
+function unsafeSegment(segment) {
+    return new ConfigPatchPathError(`Unsafe config path segment: ${segment || '<empty>'}`);
+}
 function lastSegment(path) {
     const segment = path[path.length - 1];
     if (!segment)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/plugin-runtime",
-  "version": "1.1.16",
+  "version": "1.1.17",
   "description": "Zero-dependency Plugin tree, Scope and atomic generation runtime for Zhin",
   "type": "module",
   "main": "./lib/index.js",