@zhin.js/plugin-runtime 1.1.12 → 1.1.13

package/lib/admission.d.ts

@@ -26,4 +26,4 @@ export interface GenerationAdmissionSource {
 }
 export declare function bindGenerationAdmission<T>(value: T, gate: GenerationAdmissionGate): T;
 export declare function collectGenerationAdmissions(values: Iterable<unknown>): ReadonlySet<GenerationAdmissionGate>;
-export declare function replaceGenerationAdmissions(previous: ReadonlySet<GenerationAdmissionGate>, next: ReadonlySet<GenerationAdmissionGate>, owner: object, acquireNext?: () => () => void): void;
+export declare function replaceGenerationAdmissions(previous: ReadonlySet<GenerationAdmissionGate>, next: ReadonlySet<GenerationAdmissionGate>, owner: object, publishNext: () => void, acquireNext?: () => () => void): void;

package/lib/admission.js

@@ -14,6 +14,8 @@ export class GenerationAdmissionGate {
             claim: (gate, owner) => { gate.#owner = owner; },
             activate: (gate, acquire) => gate.#activate(acquire),
             deactivate: (gate) => gate.#deactivate(),
+            notifyActivation: (gate) => gate.#notifyActivation(),
+            notifyDeactivation: (gate) => gate.#notifyDeactivation(),
         };
     }
     get active() {
@@ -72,6 +74,8 @@ export class GenerationAdmissionGate {
     }
     #activate(acquire) {
         this.#state = { active: true, acquire };
+    }
+    #notifyActivation() {
         for (const listener of this.#activationListeners) {
             try {
                 listener();
@@ -85,6 +89,8 @@ export class GenerationAdmissionGate {
     }
     #deactivate() {
         this.#state = { active: false };
+    }
+    #notifyDeactivation() {
         for (const listener of this.#deactivationListeners) {
             try {
                 listener();
@@ -130,7 +136,7 @@ export function collectGenerationAdmissions(values) {
     }
     return result;
 }
-export function replaceGenerationAdmissions(previous, next, owner, acquireNext) {
+export function replaceGenerationAdmissions(previous, next, owner, publishNext, acquireNext) {
     // Validate the complete switch before changing ownership or visibility. A
     // rejected cross-Root gate must leave both generations exactly untouched.
     for (const gate of next)
@@ -138,6 +144,9 @@ export function replaceGenerationAdmissions(previous, next, owner, acquireNext)
     for (const gate of previous) {
         admissionLifecycle.assertOwner(gate, owner);
     }
+    // This callback is SnapshotStore's infallible pointer assignment. Every
+    // potentially rejecting ownership check has completed before publication.
+    publishNext();
     for (const gate of next)
         admissionLifecycle.claim(gate, owner);
     for (const gate of previous) {
@@ -148,6 +157,14 @@ export function replaceGenerationAdmissions(previous, next, owner, acquireNext)
     for (const gate of next) {
         admissionLifecycle.activate(gate, acquireNext);
     }
+    // Publish the complete gate vector before any callback can enter the gateway
+    // or synchronously use another candidate-owned service.
+    for (const gate of previous) {
+        if (!next.has(gate))
+            admissionLifecycle.notifyDeactivation(gate);
+    }
+    for (const gate of next)
+        admissionLifecycle.notifyActivation(gate);
 }
 function isObject(value) {
     return (typeof value === 'object' && value !== null) || typeof value === 'function';

package/lib/database-host.d.ts

@@ -1,5 +1,8 @@
 import type { PluginId } from './identity.js';
 import { OwnerScopedResourceHost } from './owner-scoped-resource-host.js';
+import { scopeSetupFinalizer } from './token.js';
+import { PluginStateStore, type PersistentStatePort } from './persistent-state.js';
+import { generationAdmissionBinder, generationAdmissionSource, type GenerationAdmissionGate } from './admission.js';
 export interface DatabaseHostSelection {
     where(query: Record<string, unknown>): DatabaseHostSelection;
     orderBy(field: string, direction?: 'ASC' | 'DESC'): DatabaseHostSelection;
@@ -71,6 +74,8 @@ export interface DatabaseHostConsole {
  * `activateNext` so models are available before commands / cron run.
  */
 export interface DatabaseHost {
+    /** Small-object persistence with database-level compare-and-swap. */
+    readonly state?: PersistentStatePort;
     readonly dialect: string;
     readonly started: boolean;
     /** Register a table schema before `start` (column defs match `@zhin.js/database`). */
@@ -104,11 +109,18 @@ export interface DatabaseHost {
 export declare function qualifyPluginResourceName(owner: PluginId, name: string): string;
 /** Owner-bound persistence facade without Console administration or raw DB access. */
 export declare class PluginDatabaseHost extends OwnerScopedResourceHost {
-    private readonly host;
+    #private;
     readonly models: {
         get(name: string): DatabaseHostModel | undefined;
     };
-    constructor(owner: PluginId, host: DatabaseHost);
+    constructor(owner: PluginId, host: DatabaseHost, admission?: GenerationAdmissionGate);
+    get state(): PluginStateStore;
+    /** @internal Bound by generation publication, never a plugin authoring operation. */
+    [generationAdmissionBinder](gate: GenerationAdmissionGate): PluginDatabaseHost;
+    /** @internal Scope-owned declaration window. */
+    [scopeSetupFinalizer](): void;
+    /** @internal Admission source collected by the Runtime. */
+    get [generationAdmissionSource](): readonly GenerationAdmissionGate[];
     get dialect(): string;
     get started(): boolean;
     define(name: string, definition: Record<string, unknown>): void;

package/lib/database-host.js

@@ -1,5 +1,8 @@
 import { OwnerScopedResourceHost, qualifyOwnedResourceName, } from './owner-scoped-resource-host.js';
-import { createToken } from './token.js';
+import { createRootPrivateToken, createToken, scopeSetupFinalizer } from './token.js';
+import { PluginStateStore } from './persistent-state.js';
+import { generationAdmissionBinder, generationAdmissionSource } from './admission.js';
+import { OwnerOperation } from './owner-operation.js';
 /**
  * Persistence surface visible to a plugin. Names are logical to the owner;
  * the Runtime maps them to private physical table names before they reach the
@@ -14,27 +17,81 @@ export function qualifyPluginResourceName(owner, name) {
 }
 /** Owner-bound persistence facade without Console administration or raw DB access. */
 export class PluginDatabaseHost extends OwnerScopedResourceHost {
-    host;
     models;
-    constructor(owner, host) {
+    #host;
+    #admission;
+    #operation;
+    constructor(owner, host, admission) {
         super(owner);
-        this.host = host;
-        this.models = Object.freeze({ get: (name) => this.host.models.get(this.qualify(name)) });
+        this.#host = host;
+        this.#admission = admission;
+        this.#operation = new OwnerOperation(admission, 'Database');
+        this.models = Object.freeze({ get: (name) => this.#operation.setup(() => {
+                const model = this.#host.models.get(this.qualify(name));
+                return model ? this.#bindModel(model) : undefined;
+            }) });
+    }
+    get state() {
+        if (!this.#host.state)
+            throw new Error('Persistent state requires a configured database with atomic state support');
+        return new PluginStateStore(super.owner, this.#host.state, undefined, this.#admission);
+    }
+    /** @internal Bound by generation publication, never a plugin authoring operation. */
+    [generationAdmissionBinder](gate) {
+        const facade = new PluginDatabaseHost(super.owner, this.#host, gate);
+        facade[scopeSetupFinalizer]();
+        return facade;
+    }
+    /** @internal Scope-owned declaration window. */
+    [scopeSetupFinalizer]() { this.#operation.endSetup(); }
+    /** @internal Admission source collected by the Runtime. */
+    get [generationAdmissionSource]() {
+        return this.#admission ? [this.#admission] : [];
     }
     get dialect() {
-        return this.host.dialect;
+        return this.#host.dialect;
     }
     get started() {
-        return this.host.started;
+        return this.#host.started;
     }
     define(name, definition) {
-        this.host.define(this.qualify(name), definition);
+        this.#operation.setup(() => this.#host.define(this.qualify(name), definition));
     }
     tables() {
-        return Object.freeze(this.host.tables().flatMap((name) => {
+        return this.#operation.setup(() => Object.freeze(this.#host.tables().flatMap((name) => {
             const logical = this.unqualify(name);
             return logical === undefined ? [] : [logical];
-        }));
+        })));
+    }
+    #bindSelection(selection) {
+        const modify = (operation) => this.#operation.setup(() => {
+            const next = operation();
+            return next === selection ? chain : this.#bindSelection(next);
+        });
+        const chain = {
+            where: (query) => modify(() => selection.where(query)),
+            orderBy: (field, direction) => modify(() => selection.orderBy(field, direction)),
+            limit: (count) => modify(() => selection.limit(count)),
+            then: (fulfilled, rejected) => this.#execute(() => Promise.resolve(selection)).then(fulfilled, rejected),
+        };
+        return Object.freeze(chain);
+    }
+    #bindModel(model) {
+        const count = model.count?.bind(model);
+        return Object.freeze({
+            select: (...fields) => this.#operation.setup(() => this.#bindSelection(model.select(...fields))),
+            insert: (row) => this.#execute(() => model.insert(row)),
+            delete: () => this.#operation.setup(() => Object.freeze({
+                where: (query) => this.#execute(() => model.delete().where(query)),
+            })),
+            update: (patch) => this.#operation.setup(() => Object.freeze({
+                where: (query) => this.#execute(() => model.update(patch).where(query)),
+            })),
+            ...(count ? { count: (query) => this.#execute(() => count(query)) } : {}),
+        });
+    }
+    async #execute(operation) {
+        return this.#operation.run(operation);
     }
 }
 /**
@@ -46,4 +103,4 @@ export class PluginDatabaseHost extends OwnerScopedResourceHost {
 /** @public Plugin-facing database facade bound to the current owner. */
 export const databaseHostToken = createToken('zhin.database.host', 'Plugin Runtime scoped database host');
 /** Root-only process host for CLI composition and Console administration. */
-export const databaseRootHostToken = createToken('zhin.database.root-host', 'Plugin Runtime root database host');
+export const databaseRootHostToken = createRootPrivateToken('zhin.database.root-host', 'Plugin Runtime root database host');

package/lib/delivery-target.d.ts

@@ -0,0 +1,20 @@
+/** JSON-safe identity of one exact endpoint and conversation. */
+export type DeliveryTarget = Readonly<{
+    readonly endpoint: Readonly<{
+        readonly adapter: string;
+        readonly id: string;
+    }>;
+    readonly kind: 'private' | 'group' | 'channel';
+    readonly id: string;
+    readonly parent?: Readonly<{
+        readonly kind: 'private' | 'group' | 'channel';
+        readonly id: string;
+    }>;
+    readonly threadId?: string;
+}>;
+/** Copies public message identity only; never retains a Message, client or generation. */
+export declare function createDeliveryTarget(message: {
+    readonly conversation: DeliveryTarget;
+}): DeliveryTarget;
+/** Validate persisted/untrusted input, returning only the canonical address fields. */
+export declare function normalizeDeliveryTarget(value: unknown): DeliveryTarget;

package/lib/delivery-target.js

@@ -0,0 +1,36 @@
+/** Copies public message identity only; never retains a Message, client or generation. */
+export function createDeliveryTarget(message) {
+    return normalizeDeliveryTarget(message.conversation);
+}
+/** Validate persisted/untrusted input, returning only the canonical address fields. */
+export function normalizeDeliveryTarget(value) {
+    const target = record(value, 'delivery target');
+    const endpoint = record(target.endpoint, 'delivery target endpoint');
+    const result = {
+        endpoint: Object.freeze({ adapter: identifier(endpoint.adapter), id: identifier(endpoint.id) }),
+        kind: kind(target.kind),
+        id: identifier(target.id),
+        ...(target.parent === undefined ? {} : { parent: parent(target.parent) }),
+        ...(target.threadId === undefined ? {} : { threadId: identifier(target.threadId) }),
+    };
+    return Object.freeze(result);
+}
+function record(value, name) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new TypeError(`Invalid ${name}`);
+    return value;
+}
+function identifier(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new TypeError('Delivery identity must be a nonempty string');
+    return value;
+}
+function kind(value) {
+    if (value !== 'private' && value !== 'group' && value !== 'channel')
+        throw new TypeError('Invalid conversation kind');
+    return value;
+}
+function parent(value) {
+    const address = record(value, 'conversation parent');
+    return Object.freeze({ kind: kind(address.kind), id: identifier(address.id) });
+}

package/lib/html-renderer.d.ts

@@ -1,4 +1,6 @@
 export interface HtmlRenderOptions {
+    /** Cooperative cancellation; callers also stop awaiting hosts that ignore it. */
+    readonly signal?: AbortSignal;
     readonly width?: number;
     /** Static raster output; defaults to PNG. */
     readonly format?: 'png' | 'jpeg' | 'webp';

package/lib/index.d.ts

@@ -31,5 +31,8 @@ export * from './component-host.js';
 export * from './outbound-host.js';
 /** @public 跨通道发送辅助：`createOutboundSender` / `sendTo`（承诺 semver）。 */
 export * from './outbound-sender.js';
+export * from './delivery-target.js';
+export * from './persistent-state.js';
 export * from './inbox.js';
 export * from './system-log.js';
+export * from './plugin-verification.js';

package/lib/index.js

@@ -31,5 +31,8 @@ export * from './component-host.js';
 export * from './outbound-host.js';
 /** @public 跨通道发送辅助：`createOutboundSender` / `sendTo`（承诺 semver）。 */
 export * from './outbound-sender.js';
+export * from './delivery-target.js';
+export * from './persistent-state.js';
 export * from './inbox.js';
 export * from './system-log.js';
+export * from './plugin-verification.js';

package/lib/outbound-host.d.ts

@@ -1,3 +1,6 @@
+import type { DeliveryTarget } from './delivery-target.js';
+import type { PluginId } from './identity.js';
+import { generationAdmissionBinder, generationAdmissionSource, type GenerationAdmissionGate } from './admission.js';
 /**
  * 未锚定 endpoint 的会话地址（结构对齐 `@zhin.js/im-contract` 的
  * `Omit<ConversationRef, 'endpoint'>`；plugin-runtime 是零依赖 kernel 层，
@@ -7,7 +10,7 @@ export interface OutboundConversation {
     readonly kind: 'private' | 'group' | 'channel';
     readonly id: string;
     readonly parent?: Readonly<{
-        readonly kind: 'group' | 'channel';
+        readonly kind: 'private' | 'group' | 'channel';
         readonly id: string;
     }>;
     readonly threadId?: string;
@@ -69,11 +72,16 @@ export interface OutboundMessage {
     readonly id: string;
 }
 export interface OutboundHost {
+    /** Sends to persisted exact identities, rejecting stale addresses instead of aliasing another bot. */
+    sendTarget?(target: DeliveryTarget, content: unknown): 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. */
     capabilities?(input: OutboundEndpointInput): OutboundEndpointCapabilities | undefined;
-    /** Returns platform message id when available (activity-feedback needs it). */
+    /**
+     * Returns the platform message id, or null when delivery completed without
+     * an id. Delivery failures reject; best-effort callers handle them explicitly.
+     */
     send(input: OutboundSendInput): Promise<string | null>;
     /** Optional: platform message reactions (icqq group emoji, etc.). */
     addReaction?(input: OutboundReactionInput): Promise<string | null>;
@@ -85,5 +93,30 @@ export interface OutboundHost {
     /** Optional: toggle the platform-native typing indicator. */
     typing?(input: OutboundTypingInput): Promise<void>;
 }
+/** 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>;
+}
+/** Preserve the sending plugin as requester, independent of the destination endpoint owner. */
+export declare class PluginOutboundHost implements OutboundHost {
+    #private;
+    readonly sendTarget?: OutboundHost['sendTarget'];
+    readonly runWithView?: OutboundHost['runWithView'];
+    readonly capabilities?: OutboundHost['capabilities'];
+    readonly addReaction?: OutboundHost['addReaction'];
+    readonly removeReaction?: OutboundHost['removeReaction'];
+    readonly recall?: OutboundHost['recall'];
+    readonly edit?: OutboundHost['edit'];
+    readonly typing?: OutboundHost['typing'];
+    constructor(owner: PluginId, host: OutboundRootHost, admission?: GenerationAdmissionGate);
+    get owner(): PluginId;
+    send(input: OutboundSendInput): Promise<string | null>;
+    /** @internal Bound by generation publication. */
+    [generationAdmissionBinder](gate: GenerationAdmissionGate): PluginOutboundHost;
+    /** @internal Admission source collected by the Runtime. */
+    get [generationAdmissionSource](): readonly GenerationAdmissionGate[];
+}
 /** @public Plugin-facing cross-platform outbound messaging Host. */
 export declare const outboundHostToken: import("./token.js").Token<OutboundHost>;
+/** Root-only process outbound port for composition and owner binding. */
+export declare const outboundRootHostToken: import("./token.js").Token<OutboundRootHost>;

package/lib/outbound-host.js

@@ -1,3 +1,59 @@
-import { createToken } from './token.js';
+import { createRootPrivateToken, createToken } from './token.js';
+import { generationAdmissionBinder, generationAdmissionSource } from './admission.js';
+import { OwnerOperation } from './owner-operation.js';
+/** Preserve the sending plugin as requester, independent of the destination endpoint owner. */
+export class PluginOutboundHost {
+    sendTarget;
+    runWithView;
+    capabilities;
+    addReaction;
+    removeReaction;
+    recall;
+    edit;
+    typing;
+    #owner;
+    #host;
+    #admission;
+    #operation;
+    constructor(owner, host, admission) {
+        this.#owner = owner;
+        this.#host = host;
+        this.#admission = admission;
+        this.#operation = new OwnerOperation(admission, 'Outbound');
+        const sendTarget = host.sendTarget?.bind(host);
+        const runWithView = host.runWithView?.bind(host);
+        const capabilities = host.capabilities?.bind(host);
+        const addReaction = host.addReaction?.bind(host);
+        const removeReaction = host.removeReaction?.bind(host);
+        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.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;
+        this.removeReaction = removeReaction ? (input) => this.#run(() => removeReaction(input)) : undefined;
+        this.recall = recall ? (input) => this.#run(() => recall(input)) : undefined;
+        this.edit = edit ? (input) => this.#run(() => edit(input)) : undefined;
+        this.typing = typing ? (input) => this.#run(() => typing(input)) : undefined;
+    }
+    get owner() { return this.#owner; }
+    async send(input) {
+        return this.#run(() => this.#host.send(input));
+    }
+    /** @internal Bound by generation publication. */
+    [generationAdmissionBinder](gate) {
+        return new PluginOutboundHost(this.#owner, this.#host, gate);
+    }
+    /** @internal Admission source collected by the Runtime. */
+    get [generationAdmissionSource]() {
+        return this.#admission ? [this.#admission] : [];
+    }
+    #run(operation) {
+        return this.#operation.run(operation);
+    }
+}
 /** @public Plugin-facing cross-platform outbound messaging Host. */
 export const outboundHostToken = createToken('zhin.outbound.host', 'Plugin Runtime outbound push host');
+/** Root-only process outbound port for composition and owner binding. */
+export const outboundRootHostToken = createRootPrivateToken('zhin.outbound.root-host', 'Plugin Runtime root outbound host');

package/lib/owner-operation.d.ts

@@ -0,0 +1,14 @@
+import type { GenerationAdmissionGate } from './admission.js';
+/** @internal Facade-local leases; detached work loses authority when its frame settles. */
+export declare class OwnerOperation {
+    #private;
+    constructor(gate: GenerationAdmissionGate | undefined, label: string);
+    /** Schema/job declarations are permitted in setup before the first publication. */
+    setup<T>(operation: () => T): T;
+    endSetup(reason?: 'seal' | 'dispose'): void;
+    /** Runtime-only staging after setup seal, never on a published or failed owner. */
+    stage<T>(operation: () => T): T;
+    /** A projection may derive a new candidate from a live owner, never a retired one. */
+    prepareProjection<T>(operation: () => T): T;
+    run<T>(operation: () => T): T;
+}

package/lib/owner-operation.js

@@ -0,0 +1,80 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** @internal Facade-local leases; detached work loses authority when its frame settles. */
+export class OwnerOperation {
+    #context = new AsyncLocalStorage();
+    #gate;
+    #label;
+    #published = false;
+    #setupOpen = true;
+    #disposed = false;
+    constructor(gate, label) {
+        this.#gate = gate;
+        this.#label = label;
+        gate?.onActivate(() => { this.#published = true; });
+    }
+    /** Schema/job declarations are permitted in setup before the first publication. */
+    setup(operation) {
+        if (!this.#gate || this.#setupOpen && !this.#published || this.#context.getStore()?.active)
+            return operation();
+        const release = this.#gate.acquire();
+        if (!release)
+            throw new Error(`${this.#label} operation belongs to an inactive generation`);
+        // A query builder may be thenable. Never assimilate it just to check access.
+        try {
+            return operation();
+        }
+        finally {
+            release();
+        }
+    }
+    endSetup(reason = 'seal') {
+        this.#setupOpen = false;
+        if (reason === 'dispose')
+            this.#disposed = true;
+    }
+    /** Runtime-only staging after setup seal, never on a published or failed owner. */
+    stage(operation) {
+        if (this.#published || this.#disposed)
+            throw new Error(`${this.#label} staging belongs to an inactive generation`);
+        return operation();
+    }
+    /** A projection may derive a new candidate from a live owner, never a retired one. */
+    prepareProjection(operation) {
+        if (this.#disposed || this.#published && !this.#gate?.active)
+            throw new Error(`${this.#label} preparation belongs to an inactive generation`);
+        return operation();
+    }
+    run(operation) {
+        if (!this.#gate)
+            return operation();
+        const parent = this.#context.getStore();
+        let lease;
+        if (parent?.active)
+            lease = parent.lease;
+        else {
+            const release = this.#gate.acquire();
+            if (!release)
+                throw new Error(`${this.#label} operation belongs to an inactive generation`);
+            lease = { pending: 0, release };
+        }
+        lease.pending++;
+        const context = { active: true, lease };
+        const finish = () => {
+            context.active = false;
+            if (--lease.pending === 0)
+                lease.release();
+        };
+        try {
+            const result = this.#context.run(context, operation);
+            if (result && typeof result.then === 'function') {
+                return Promise.resolve(result).finally(finish);
+            }
+            finish();
+            return result;
+        }
+        catch (error) {
+            finish();
+            throw error;
+        }
+    }
+}

package/lib/owner-scoped-resource-host.d.ts

@@ -1,8 +1,9 @@
 import { type PluginId } from './identity.js';
 /** Shared owner identity and physical-name invariant for process-wide resources. */
 export declare abstract class OwnerScopedResourceHost {
-    readonly owner: PluginId;
+    #private;
     constructor(owner: PluginId);
+    get owner(): PluginId;
     protected qualify(name: string): string;
     protected unqualify(name: string): string | undefined;
 }

package/lib/owner-scoped-resource-host.js

@@ -3,16 +3,15 @@ const resourcePrefix = '__zhin_plugin__';
 const resourceSeparator = '__';
 /** Shared owner identity and physical-name invariant for process-wide resources. */
 export class OwnerScopedResourceHost {
-    owner;
-    constructor(owner) {
-        this.owner = owner;
-    }
+    #owner;
+    constructor(owner) { this.#owner = owner; }
+    get owner() { return this.#owner; }
     qualify(name) {
         assertLogicalName(name);
-        return qualifyOwnedResourceName(this.owner, name);
+        return qualifyOwnedResourceName(this.#owner, name);
     }
     unqualify(name) {
-        const prefix = `${resourcePrefix}${pluginOwnerResourceKey(this.owner)}${resourceSeparator}`;
+        const prefix = `${resourcePrefix}${pluginOwnerResourceKey(this.#owner)}${resourceSeparator}`;
         return name.startsWith(prefix) ? name.slice(prefix.length) : undefined;
     }
 }

package/lib/persistent-state.d.ts

@@ -0,0 +1,45 @@
+import { type DeliveryTarget } from './delivery-target.js';
+import type { PluginId } from './identity.js';
+import type { GenerationAdmissionGate } from './admission.js';
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export type StateScope = Readonly<{
+    kind: 'plugin';
+}> | Readonly<{
+    kind: 'user';
+    endpoint: DeliveryTarget['endpoint'];
+    senderId: string;
+}> | Readonly<{
+    kind: 'conversation';
+    target: DeliveryTarget;
+}>;
+/** Opaque database revision, including expired rows so updates cannot resurrect stale values. */
+export interface StateRecord {
+    readonly revision: string;
+    readonly value: JsonValue;
+    readonly expiresAt: number | null;
+}
+/** Process-owned port backed by the existing database, never an in-memory persistence fallback. */
+export interface PersistentStatePort {
+    read(owner: PluginId, scope: StateScope, key: string): Promise<StateRecord | undefined>;
+    compareExchange(owner: PluginId, scope: StateScope, key: string, revision: string | undefined, value: JsonValue | undefined, expiresAt: number | null): Promise<boolean>;
+}
+export interface StateWriteOptions {
+    /** Milliseconds from this write attempt; omission stores without expiry. */
+    readonly ttlMs?: number;
+}
+/** Owner-bound small-object state. Updaters must be pure: contention can replay them. */
+export declare class PluginStateStore {
+    #private;
+    constructor(owner: PluginId, port: PersistentStatePort, scope?: StateScope, admission?: GenerationAdmissionGate);
+    get owner(): PluginId;
+    forUser(endpoint: DeliveryTarget['endpoint'], senderId: string): PluginStateStore;
+    forConversation(target: DeliveryTarget): PluginStateStore;
+    get<T extends JsonValue = JsonValue>(key: string): Promise<T | undefined>;
+    set<T extends JsonValue>(key: string, value: T, options?: StateWriteOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+    update<T extends JsonValue = JsonValue>(key: string, updater: (current: T | undefined) => T | undefined, options?: StateWriteOptions): Promise<T | undefined>;
+}
+/** Reject lossy JSON conversions instead of silently losing a Date, NaN, undefined or callback. */
+export declare function copyJson(value: JsonValue): JsonValue;

package/lib/persistent-state.js

@@ -0,0 +1,124 @@
+import { normalizeDeliveryTarget } from './delivery-target.js';
+/** Owner-bound small-object state. Updaters must be pure: contention can replay them. */
+export class PluginStateStore {
+    #owner;
+    #port;
+    #scope;
+    #admission;
+    constructor(owner, port, scope = Object.freeze({ kind: 'plugin' }), admission) {
+        this.#owner = owner;
+        this.#port = port;
+        this.#scope = scope;
+        this.#admission = admission;
+    }
+    get owner() { return this.#owner; }
+    forUser(endpoint, senderId) {
+        if (!senderId)
+            throw new TypeError('State senderId must be nonempty');
+        const canonical = normalizeDeliveryTarget({ endpoint, kind: 'private', id: senderId });
+        return new PluginStateStore(this.#owner, this.#port, Object.freeze({ kind: 'user', endpoint: canonical.endpoint, senderId }), this.#admission);
+    }
+    forConversation(target) {
+        return new PluginStateStore(this.#owner, this.#port, Object.freeze({ kind: 'conversation', target: normalizeDeliveryTarget(target) }), this.#admission);
+    }
+    async get(key) {
+        return this.#withAdmission(async () => {
+            assertKey(key);
+            const record = await this.#port.read(this.#owner, this.#scope, key);
+            return record && (record.expiresAt === null || record.expiresAt > Date.now())
+                ? copyJson(record.value) : undefined;
+        });
+    }
+    async set(key, value, options) {
+        const json = copyJson(value);
+        await this.update(key, () => json, options);
+    }
+    async delete(key) {
+        await this.update(key, () => undefined);
+    }
+    async update(key, updater, options) {
+        return this.#withAdmission(async () => {
+            assertKey(key);
+            const ttl = options?.ttlMs;
+            if (ttl !== undefined && (!Number.isSafeInteger(ttl) || ttl <= 0))
+                throw new TypeError('ttlMs must be a positive integer');
+            for (let attempt = 0; attempt < 64; attempt++) {
+                const record = await this.#port.read(this.#owner, this.#scope, key);
+                const live = record && (record.expiresAt === null || record.expiresAt > Date.now());
+                const next = updater(live ? copyJson(record.value) : undefined);
+                const value = next === undefined ? undefined : copyJson(next);
+                const expiresAt = ttl === undefined ? null : Date.now() + ttl;
+                if (expiresAt !== null && !Number.isSafeInteger(expiresAt))
+                    throw new TypeError('ttlMs exceeds supported time range');
+                if (await this.#port.compareExchange(this.#owner, this.#scope, key, record?.revision, value, expiresAt)) {
+                    return value === undefined ? undefined : copyJson(value);
+                }
+            }
+            throw new Error('Persistent state update contention exceeded 64 retries; retry the operation');
+        });
+    }
+    async #withAdmission(operation) {
+        if (!this.#admission)
+            return operation();
+        const release = this.#admission.acquire();
+        if (!release)
+            throw new Error('Persistent state operation belongs to an inactive generation');
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+}
+function assertKey(key) {
+    if (!key || key.length > 256)
+        throw new TypeError('State key must contain 1–256 characters');
+}
+/** Reject lossy JSON conversions instead of silently losing a Date, NaN, undefined or callback. */
+export function copyJson(value) {
+    const ancestors = new Set();
+    const visit = (item) => {
+        if (item === null || typeof item === 'string' || typeof item === 'boolean')
+            return;
+        if (typeof item === 'number' && Number.isFinite(item) && !Object.is(item, -0))
+            return;
+        if (!item || typeof item !== 'object')
+            throw new TypeError('Persistent state must be JSON-safe');
+        if (ancestors.has(item))
+            throw new TypeError('Persistent state must not contain cycles');
+        if (Array.isArray(item) ? Object.getPrototypeOf(item) !== Array.prototype
+            : Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null) {
+            throw new TypeError('Persistent state objects must be plain JSON objects');
+        }
+        if (Object.getOwnPropertySymbols(item).length)
+            throw new TypeError('Persistent state must not contain symbol properties');
+        if ('toJSON' in item && !Object.hasOwn(item, 'toJSON'))
+            throw new TypeError('Persistent state must not inherit toJSON');
+        if (Array.isArray(item)) {
+            for (let index = 0; index < item.length; index++) {
+                if (!Object.hasOwn(item, index))
+                    throw new TypeError('Persistent state arrays must not contain holes');
+            }
+        }
+        ancestors.add(item);
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(item))) {
+            if (Array.isArray(item) && key === 'length')
+                continue;
+            if (!descriptor.enumerable || !('value' in descriptor))
+                throw new TypeError('Persistent state must contain ordinary enumerable JSON properties');
+            if (Array.isArray(item) && (!/^\d+$/u.test(key) || String(Number(key)) !== key || Number(key) >= item.length)) {
+                throw new TypeError('Persistent state arrays must contain only indexed JSON values');
+            }
+        }
+        for (const child of Array.isArray(item) ? item : Object.values(item))
+            visit(child);
+        ancestors.delete(item);
+    };
+    visit(value);
+    const serialized = JSON.stringify(value);
+    // MySQL TEXT has a 65535-byte limit. Keep the same contract on every supported dialect.
+    if (new TextEncoder().encode(serialized).byteLength >= 64 * 1024)
+        throw new TypeError('Persistent state value must be below 64 KiB');
+    return JSON.parse(serialized);
+}

package/lib/plugin-verification.d.ts

@@ -0,0 +1,18 @@
+/** A deliberate business check. Effects must describe every write or external action. */
+export interface PluginVerificationCheck {
+    readonly id: string;
+    readonly title: string;
+    readonly effects: readonly string[];
+    readonly scope: 'local' | 'platform';
+}
+export interface PluginVerificationOutcome {
+    readonly status: 'passed' | 'failed';
+    readonly summary: string;
+    readonly evidence: readonly string[];
+}
+/** Plugin-owned optional verification, distinct from generation publication/readiness. */
+export interface PluginVerificationHost {
+    checks(): readonly PluginVerificationCheck[];
+    run(checkId: string): Promise<PluginVerificationOutcome>;
+}
+export declare const pluginVerificationToken: import("./token.js").Token<PluginVerificationHost>;

package/lib/plugin-verification.js

@@ -0,0 +1,2 @@
+import { createToken } from './token.js';
+export const pluginVerificationToken = createToken('zhin.plugin-verification', 'Explicit plugin business checks, executed only on user request');

package/lib/plugin.d.ts

@@ -14,6 +14,11 @@ export interface PluginMetadata {
 export interface ConfigView<T> {
     get(): Readonly<T>;
 }
+/** Structural schema contract; the Runtime owns validation and defaults. */
+export interface PluginConfigSchema<TConfig> {
+    readonly output?: TConfig;
+    toJsonSchema(): Readonly<Record<string, unknown>>;
+}
 export interface PluginInstanceView {
     readonly id: PluginId;
     readonly instanceKey: string;
@@ -37,6 +42,7 @@ export interface PluginSetupContext<TConfig = unknown> {
 }
 export interface PluginDefinition<TConfig = unknown> {
     readonly name: string;
+    readonly config?: PluginConfigSchema<TConfig>;
     readonly metadata?: PluginMetadata;
     readonly requires?: readonly Token<unknown>[];
     setup?(context: PluginSetupContext<TConfig>): void | Dispose | Promise<void | Dispose>;
@@ -60,6 +66,8 @@ export interface PluginDefinition<TConfig = unknown> {
  * one default export.
  */
 export declare function definePlugin<TConfig = unknown>(definition: PluginDefinition<TConfig>): Readonly<PluginDefinition<TConfig>>;
+export { createDeliveryTarget, type DeliveryTarget } from './delivery-target.js';
+export { PluginStateStore, type JsonValue, type StateScope, type StateRecord, type PersistentStatePort, type StateWriteOptions } from './persistent-state.js';
 export { databaseHostToken, type DatabaseHostConsole, type DatabaseHostModel, type DatabaseHostSelection, type DatabaseHostSelectResult, type DatabaseHostTable, type DatabaseHostType, PluginDatabaseHost, } from './database-host.js';
 export { outboundHostToken, type OutboundConversation, type OutboundEditInput, type OutboundEndpointCapabilities, type OutboundEndpointInput, type OutboundEndpointOperation, type OutboundHost, type OutboundMessage, type OutboundReactionInput, type OutboundRecallInput, type OutboundRemoveReactionInput, type OutboundSendInput, type OutboundTypingInput, } from './outbound-host.js';
 export { scheduleHostToken, PluginScheduleHost, type ScheduleJobRegistration, } from './schedule-host.js';

package/lib/plugin.js

@@ -21,6 +21,9 @@ export function definePlugin(definition) {
     if (!pluginNamePattern.test(definition.name)) {
         throw new TypeError(`Invalid plugin name: ${definition.name}`);
     }
+    if (definition.config !== undefined && typeof definition.config.toJsonSchema !== 'function') {
+        throw new TypeError('Plugin config must declare a schema with toJsonSchema()');
+    }
     return Object.freeze({
         ...definition,
         metadata: definition.metadata ? Object.freeze({ ...definition.metadata }) : undefined,
@@ -28,6 +31,8 @@ export function definePlugin(definition) {
     });
 }
 // The application facade exposes these Host contracts beside definePlugin.
+export { createDeliveryTarget } from './delivery-target.js';
+export { PluginStateStore } from './persistent-state.js';
 export { databaseHostToken, PluginDatabaseHost, } from './database-host.js';
 export { outboundHostToken, } from './outbound-host.js';
 export { scheduleHostToken, PluginScheduleHost, } from './schedule-host.js';

package/lib/schedule-host.d.ts

@@ -1,5 +1,7 @@
 import type { PluginId } from './identity.js';
 import { OwnerScopedResourceHost } from './owner-scoped-resource-host.js';
+import { scopeSetupFinalizer } from './token.js';
+import { generationAdmissionBinder, generationAdmissionSource, type GenerationAdmissionGate } from './admission.js';
 /**
  * Thin Host Resource for Plugin Runtime cron jobs.
  * Implementations typically wrap `@zhin.js/schedule` CalendarScheduler (solar cron).
@@ -11,10 +13,16 @@ export interface ScheduleJobRegistration {
     /** 6-field solar cron: `秒 分 时 日 月 周` */
     readonly cron: string;
     readonly description?: string;
+    /** @internal Process Host visibility follows atomic generation publication. */
+    readonly isActive?: () => boolean;
     execute(): void | Promise<void>;
 }
 export interface ScheduleHost {
-    /** Register a solar cron job; returns disposer that cancels the job. */
+    /**
+     * Register a solar cron job; its disposer cancels only this registration.
+     * Overlapping generations may share a logical id. Preserve both until their
+     * disposers run, and use isActive to select the published registration.
+     */
     register(job: ScheduleJobRegistration): () => void;
     list(): readonly {
         readonly id: string;
@@ -25,17 +33,34 @@ export interface ScheduleHost {
 }
 /** Scoped scheduling surface exposed to a Plugin setup function. */
 export declare function qualifyPluginScheduleId(owner: PluginId, id: string): string;
+declare const stageRegistration: unique symbol;
+declare const prepareProjection: unique symbol;
+/** @internal Each Schedule projection owns its own candidate registration gate. */
+export declare function createPluginScheduleCandidate(host: PluginScheduleHost, gate: GenerationAdmissionGate): PluginScheduleHost;
+/** @internal Schedule Feature stages candidate jobs before atomic publication. */
+export declare function stagePluginScheduleRegistration(host: PluginScheduleHost, job: ScheduleJobRegistration): () => void;
 export declare class PluginScheduleHost extends OwnerScopedResourceHost {
-    private readonly host;
-    constructor(owner: PluginId, host: ScheduleHost);
+    #private;
+    constructor(owner: PluginId, host: ScheduleHost, admission?: GenerationAdmissionGate);
     register(job: ScheduleJobRegistration): () => void;
+    /** @internal Runtime-only candidate preparation; the key is private to this module. */
+    [stageRegistration](job: ScheduleJobRegistration): () => void;
+    /** @internal Derive a fresh candidate without reopening this owner facade. */
+    [prepareProjection](gate: GenerationAdmissionGate): PluginScheduleHost;
     list(): readonly {
         readonly id: string;
         readonly cron: string;
         readonly description?: string;
     }[];
+    /** @internal Bound by generation publication. */
+    [generationAdmissionBinder](gate: GenerationAdmissionGate): PluginScheduleHost;
+    /** @internal Scope-owned declaration window. */
+    [scopeSetupFinalizer](reason?: 'seal' | 'dispose'): void;
+    /** @internal Admission source collected by the Runtime. */
+    get [generationAdmissionSource](): readonly GenerationAdmissionGate[];
 }
 /** @public Plugin-facing token; Runtime injects a facade bound to the current owner. */
 export declare const scheduleHostToken: import("./token.js").Token<PluginScheduleHost>;
 /** Root-only process scheduler for CLI composition and Console administration. */
 export declare const scheduleRootHostToken: import("./token.js").Token<ScheduleHost>;
+export {};

package/lib/schedule-host.js

@@ -1,20 +1,54 @@
 import { OwnerScopedResourceHost, qualifyOwnedResourceName, } from './owner-scoped-resource-host.js';
-import { createToken } from './token.js';
+import { createToken, createRootPrivateToken, scopeSetupFinalizer } from './token.js';
+import { generationAdmissionBinder, generationAdmissionSource } from './admission.js';
+import { OwnerOperation } from './owner-operation.js';
 /** Scoped scheduling surface exposed to a Plugin setup function. */
 export function qualifyPluginScheduleId(owner, id) {
     return qualifyOwnedResourceName(owner, id);
 }
+const stageRegistration = Symbol('StageScheduleRegistration');
+const prepareProjection = Symbol('PrepareScheduleProjection');
+/** @internal Each Schedule projection owns its own candidate registration gate. */
+export function createPluginScheduleCandidate(host, gate) {
+    return host[prepareProjection](gate);
+}
+/** @internal Schedule Feature stages candidate jobs before atomic publication. */
+export function stagePluginScheduleRegistration(host, job) {
+    return host[stageRegistration](job);
+}
 export class PluginScheduleHost extends OwnerScopedResourceHost {
-    host;
-    constructor(owner, host) {
+    #host;
+    #admission;
+    #operation;
+    constructor(owner, host, admission) {
         super(owner);
-        this.host = host;
+        this.#host = host;
+        this.#admission = admission;
+        this.#operation = new OwnerOperation(admission, 'Schedule');
     }
     register(job) {
-        return this.host.register({ ...job, id: this.qualify(job.id), owner: this.owner });
+        return this.#operation.setup(() => this.#register(job));
+    }
+    /** @internal Runtime-only candidate preparation; the key is private to this module. */
+    [stageRegistration](job) {
+        return this.#operation.stage(() => this.#register(job));
+    }
+    /** @internal Derive a fresh candidate without reopening this owner facade. */
+    [prepareProjection](gate) {
+        return this.#operation.prepareProjection(() => {
+            const candidate = new PluginScheduleHost(super.owner, this.#host, gate);
+            candidate[scopeSetupFinalizer]('seal');
+            return candidate;
+        });
+    }
+    #register(job) {
+        return this.#host.register({ ...job, id: this.qualify(job.id), owner: super.owner,
+            isActive: () => this.#admission?.active ?? true,
+            execute: () => this.#operation.run(() => job.execute()),
+        });
     }
     list() {
-        return Object.freeze(this.host.list().flatMap((job) => {
+        return this.#operation.setup(() => Object.freeze(this.#host.list().flatMap((job) => {
             const id = this.unqualify(job.id);
             if (id === undefined)
                 return [];
@@ -23,10 +57,22 @@ export class PluginScheduleHost extends OwnerScopedResourceHost {
                     cron: job.cron,
                     ...(job.description === undefined ? {} : { description: job.description }),
                 })];
-        }));
+        })));
+    }
+    /** @internal Bound by generation publication. */
+    [generationAdmissionBinder](gate) {
+        const facade = new PluginScheduleHost(super.owner, this.#host, gate);
+        facade[scopeSetupFinalizer]('dispose');
+        return facade;
+    }
+    /** @internal Scope-owned declaration window. */
+    [scopeSetupFinalizer](reason = 'seal') { this.#operation.endSetup(reason); }
+    /** @internal Admission source collected by the Runtime. */
+    get [generationAdmissionSource]() {
+        return this.#admission ? [this.#admission] : [];
     }
 }
 /** @public Plugin-facing token; Runtime injects a facade bound to the current owner. */
 export const scheduleHostToken = createToken('zhin.schedule.host', 'Plugin Runtime scoped solar cron host');
 /** Root-only process scheduler for CLI composition and Console administration. */
-export const scheduleRootHostToken = createToken('zhin.schedule.root-host', 'Plugin Runtime root solar cron host');
+export const scheduleRootHostToken = createRootPrivateToken('zhin.schedule.root-host', 'Plugin Runtime root solar cron host');

package/lib/snapshot.d.ts

@@ -7,10 +7,14 @@ export interface PluginNodeSnapshot {
     readonly id: PluginId;
     readonly instanceKey: string;
     readonly packageName: string;
+    /** Package version read when this owner was assembled, never from later disk contents. */
+    readonly packageVersion?: string;
     readonly packageRoot: string;
     readonly parent?: PluginId;
     readonly children: readonly PluginId[];
     readonly metadata?: PluginMetadata;
+    /** Immutable schema declaration belonging to this committed generation. */
+    readonly configSchema?: Readonly<Record<string, unknown>>;
 }
 export interface RuntimeSnapshot {
     readonly generation: number;

package/lib/snapshot.js

@@ -51,8 +51,8 @@ export class SnapshotStore {
             leases: 0,
             retired: false,
         };
-        replaceGenerationAdmissions(new Set(), admissions, this, () => this.#retain(record));
         this.#current = record;
+        replaceGenerationAdmissions(new Set(), admissions, this, () => undefined, () => this.#retain(record));
     }
     get current() {
         return this.#current.snapshot;
@@ -95,10 +95,9 @@ export class SnapshotStore {
             leases: 0,
             retired: false,
         };
-        replaceGenerationAdmissions(previous.admissions, admissions, this, () => this.#retain(next));
+        replaceGenerationAdmissions(previous.admissions, admissions, this, () => { this.#current = next; }, () => this.#retain(next));
         // Commit only swaps the active pointer. The previous record may still be
         // serving in-flight work, so disposal is deferred to its final lease.
-        this.#current = next;
         previous.retired = true;
         this.#retired.add(previous);
         this.#disposeIfReady(previous);
@@ -108,7 +107,7 @@ export class SnapshotStore {
         if (this.#closed)
             return;
         this.#closed = true;
-        replaceGenerationAdmissions(this.#current.admissions, new Set(), this);
+        replaceGenerationAdmissions(this.#current.admissions, new Set(), this, () => undefined);
         this.#current.retired = true;
         this.#retired.add(this.#current);
         this.#disposeIfReady(this.#current);
@@ -168,13 +167,23 @@ export function createSnapshotView(generation, state) {
     return Object.freeze({
         ...state,
         generation,
-        tree: readonlyMap(state.tree),
+        tree: readonlyMap([...state.tree].map(([owner, node]) => [owner, node.configSchema
+                ? Object.freeze({ ...node, configSchema: freezeSchema(structuredClone(node.configSchema)) })
+                : node])),
         config: readonlyMap(state.config),
         resources: readonlyMap([...state.resources].map(([owner, resources]) => [owner, readonlyMap(resources)])),
         capabilities: readonlyMap(state.capabilities),
         projections: readonlyMap(state.projections),
     });
 }
+function freezeSchema(value) {
+    if (value && typeof value === 'object') {
+        for (const child of Object.values(value))
+            freezeSchema(child);
+        Object.freeze(value);
+    }
+    return value;
+}
 class ReadonlyMapView {
     #values;
     constructor(entries) {

package/lib/token.d.ts

@@ -7,12 +7,13 @@ export interface Token<T> {
 }
 export declare function createToken<T>(id: string, description?: string): Token<T>;
 export declare function createRootPrivateToken<T>(id: string, description?: string): Token<T>;
+/** @internal Ends a facade's candidate declarations on seal or failed setup disposal. */
+export declare const scopeSetupFinalizer: unique symbol;
 export declare class Scope {
     #private;
     readonly owner: PluginId;
-    readonly parent?: Scope | undefined;
     readonly disposers: DisposeStack;
-    constructor(owner: PluginId, parent?: Scope | undefined, disposers?: DisposeStack);
+    constructor(owner: PluginId, parent?: Scope, disposers?: DisposeStack);
     provide<T>(token: Token<T>, value: T, dispose?: Dispose): void;
     use<T>(token: Token<T>): T;
     has<T>(token: Token<T>): boolean;

package/lib/token.js

@@ -9,16 +9,19 @@ export function createRootPrivateToken(id, description) {
     rootPrivateTokens.add(token);
     return Object.freeze(token);
 }
+/** @internal Ends a facade's candidate declarations on seal or failed setup disposal. */
+export const scopeSetupFinalizer = Symbol('ScopeSetupFinalizer');
 export class Scope {
     owner;
-    parent;
     disposers;
     #bindings = new Map();
+    #parent;
+    #setupFinalizers = new Set();
     #sealed = false;
     constructor(owner, parent, disposers = new DisposeStack()) {
         this.owner = owner;
-        this.parent = parent;
         this.disposers = disposers;
+        this.#parent = parent;
     }
     provide(token, value, dispose) {
         if (this.#sealed)
@@ -32,6 +35,14 @@ export class Scope {
             rootPrivate: rootPrivateTokens.has(token),
             token,
         }));
+        if (value && typeof value === 'object') {
+            const finalize = value[scopeSetupFinalizer];
+            if (typeof finalize === 'function') {
+                const endSetup = (reason) => finalize.call(value, reason);
+                this.#setupFinalizers.add(endSetup);
+                this.disposers.add(() => endSetup('dispose'));
+            }
+        }
         if (dispose)
             this.disposers.add(dispose);
     }
@@ -42,8 +53,8 @@ export class Scope {
                 return binding.value;
             throw new Error(`Missing resource ${token.id} for ${this.owner}`);
         }
-        const inherited = this.parent
-            ? this.parent.#resolveForDescendant(token.id)
+        const inherited = this.#parent
+            ? this.#parent.#resolveForDescendant(token.id)
             : undefined;
         if (inherited?.status === 'found')
             return inherited.binding.value;
@@ -53,19 +64,22 @@ export class Scope {
         const binding = this.#bindings.get(token.id);
         if (binding)
             return !binding.rootPrivate || binding.token === token;
-        return this.parent
-            ? this.parent.#resolveForDescendant(token.id)?.status === 'found'
+        return this.#parent
+            ? this.#parent.#resolveForDescendant(token.id)?.status === 'found'
             : false;
     }
     seal() {
         this.#sealed = true;
+        for (const finalize of this.#setupFinalizers)
+            finalize('seal');
+        this.#setupFinalizers.clear();
         this.disposers.seal();
     }
     snapshot() {
         if (!this.#sealed)
             throw new Error(`Scope is not sealed: ${this.owner}`);
-        const result = this.parent
-            ? new Map(this.parent.snapshot())
+        const result = this.#parent
+            ? new Map(this.#parent.snapshot())
             : new Map();
         for (const [id, binding] of this.#bindings) {
             if (!binding.rootPrivate)
@@ -80,6 +94,6 @@ export class Scope {
                 ? Object.freeze({ status: 'blocked' })
                 : Object.freeze({ status: 'found', binding });
         }
-        return this.parent ? this.parent.#resolveForDescendant(id) : undefined;
+        return this.#parent ? this.#parent.#resolveForDescendant(id) : undefined;
     }
 }

package/package.json

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