@zhin.js/runtime 1.0.7 → 1.0.10

package/lib/config-composer.js

@@ -37,7 +37,7 @@ export class ConfigComposer {
             await composeNode(child, ownSchemas),
         ]));
         // Host-level keys (`http`, `database`, `ai`, `mcp`, `a2a`, `speech`,
-        // `htmlRenderer`, `assistant`, `collaboration`, `log_level`) are consumed by CLI Root installers /
+        // `htmlRenderer`, `assistant`, `log_level`) are consumed by CLI Root installers /
         // start-command, not Plugin ConfigViews.
         const effectiveSchema = Object.freeze({
             type: 'object',
@@ -82,10 +82,6 @@ export class ConfigComposer {
                     type: 'object',
                     additionalProperties: true,
                 }),
-                collaboration: Object.freeze({
-                    type: 'object',
-                    additionalProperties: true,
-                }),
                 log_level: Object.freeze({
                     type: ['string', 'number'],
                 }),
@@ -119,12 +115,12 @@ export class ConfigComposer {
 const FRAMEWORK_ROLE_SCHEMA = Object.freeze({
     master: Object.freeze({
         type: ['string', 'number'],
-        description: 'Endpoint owner (framework-level master role)',
+        description: 'Framework master user id (AI/tool privileges; not group owner/admin)',
     }),
     trusted: Object.freeze({
         type: 'array',
         items: Object.freeze({ type: ['string', 'number'] }),
-        description: 'Trusted user ID list (framework-level trusted role)',
+        description: 'Framework trusted user id list (weaker than master)',
     }),
 });
 function hasArrayEndpoints(props) {
@@ -133,18 +129,50 @@ function hasArrayEndpoints(props) {
         return false;
     return ep.type === 'array';
 }
+/** 顶层 + endpoints[].properties 注入 master/trusted（已声明则不覆盖） */
+function injectFrameworkRoleSchema(properties) {
+    for (const [key, schema] of Object.entries(FRAMEWORK_ROLE_SCHEMA)) {
+        if (!Object.hasOwn(properties, key)) {
+            properties[key] = schema;
+        }
+    }
+    if (!hasArrayEndpoints(properties))
+        return;
+    const ep = properties.endpoints;
+    const items = ep.items;
+    if (!items || typeof items !== 'object' || Array.isArray(items))
+        return;
+    const itemsObj = items;
+    const rawProps = itemsObj.properties;
+    const itemProps = rawProps && typeof rawProps === 'object' && !Array.isArray(rawProps)
+        ? { ...rawProps }
+        : {};
+    let changed = false;
+    for (const [key, schema] of Object.entries(FRAMEWORK_ROLE_SCHEMA)) {
+        if (!Object.hasOwn(itemProps, key)) {
+            itemProps[key] = schema;
+            changed = true;
+        }
+    }
+    if (!changed)
+        return;
+    properties.endpoints = Object.freeze({
+        ...ep,
+        items: Object.freeze({
+            ...itemsObj,
+            properties: Object.freeze(itemProps),
+        }),
+    });
+}
 async function composeNode(node, ownSchemas) {
     const own = await readOwnSchema(node);
     ownSchemas.set(node.id, own);
     const properties = { ...schemaProperties(own) };
     // Adapter plugins (schemas declaring array-typed `endpoints`) get
-    // framework-level `master` / `trusted` injected when not already declared.
+    // framework-level `master` / `trusted` injected when not already declared
+    // (top-level and endpoints[].properties).
     if (hasArrayEndpoints(properties)) {
-        for (const [key, schema] of Object.entries(FRAMEWORK_ROLE_SCHEMA)) {
-            if (!Object.hasOwn(properties, key)) {
-                properties[key] = schema;
-            }
-        }
+        injectFrameworkRoleSchema(properties);
     }
     for (const child of node.children) {
         if (Object.hasOwn(properties, child.instanceKey)) {

package/lib/feature-projector.d.ts

@@ -10,6 +10,6 @@ export interface ProjectedFeatures {
 export declare class FeatureProjector {
     private readonly providers;
     constructor(providers: Iterable<FeatureProvider>);
-    project(generation: number, base: ProjectionState, retained?: ReadonlyMap<FeatureId, unknown>): Promise<ProjectedFeatures>;
+    project(generation: number, base: ProjectionState, signal: AbortSignal, retained?: ReadonlyMap<FeatureId, unknown>): Promise<ProjectedFeatures>;
 }
 export declare function composeGenerationHandoffs(...handoffs: readonly (GenerationHandoff | undefined)[]): GenerationHandoff | undefined;

package/lib/feature-projector.js

@@ -5,7 +5,7 @@ export class FeatureProjector {
     constructor(providers) {
         this.providers = providers;
     }
-    async project(generation, base, retained = new Map()) {
+    async project(generation, base, signal, retained = new Map()) {
         // Slot HMR seeds this map with the committed projections. Only providers
         // passed to this projector replace their entry; every other Feature keeps
         // its live instance and therefore keeps its external resources running.
@@ -15,10 +15,13 @@ export class FeatureProjector {
         const state = { ...base, projections };
         try {
             for (const provider of this.providers) {
+                signal.throwIfAborted();
                 const slots = [...base.capabilities.values()].filter((slot) => slot.feature === provider.id);
                 const projection = await provider.runtime.project(slots, {
                     snapshot: createSnapshotView(generation, state),
+                    signal,
                 });
+                signal.throwIfAborted();
                 projections.set(provider.id, projection.value);
                 if (projection.dispose)
                     disposers.set(provider.id, projection.dispose);

package/lib/isolation.d.ts

@@ -24,5 +24,5 @@ export interface PreparedIsolatedPlugin {
 }
 /** Adapter seam for child Plugin lifecycle that must not execute in the Host realm. */
 export interface IsolatedPluginRuntimePort {
-    prepare(request: IsolatedPluginPrepareRequest): Promise<PreparedIsolatedPlugin>;
+    prepare(request: IsolatedPluginPrepareRequest, signal: AbortSignal): Promise<PreparedIsolatedPlugin>;
 }

package/lib/native-development-runtime.js

@@ -2,7 +2,7 @@ import { readdirSync, statSync, watch as watchDirectory, } from 'node:fs';
 import { extname, isAbsolute, relative, resolve, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 const ignoredDirectories = new Set([
-    '.git', '.zhin', 'coverage', 'dist', 'lib', 'node_modules',
+    '.git', '.zhin', 'coverage', 'data', 'dist', 'lib', 'node_modules',
 ]);
 const watchedExtensions = new Set([
     '.cjs', '.js', '.json', '.md', '.mjs', '.ts', '.tsx', '.yaml', '.yml',

package/lib/plugin-scope-assembler.d.ts

@@ -1,4 +1,4 @@
-import { DisposeStack, Scope, type Dispose, type FeatureId, type GenerationHandoff, type GenerationHandoffRegistry, type PluginId, type PluginNodeSnapshot, type SetupCapabilityRegistration, type TokenId } from '@zhin.js/plugin-runtime';
+import { DisposeStack, Scope, type Dispose, type FeatureId, type GenerationHandoff, type GenerationAdmissionGate, type GenerationHandoffRegistry, type PluginId, type PluginNodeSnapshot, type SetupCapabilityRegistration, type TokenId } from '@zhin.js/plugin-runtime';
 import { type RuntimeEnvironment } from './environment.js';
 import { type EnvironmentLayers } from './environment-store.js';
 import type { ModuleRuntime } from './module-runtime.js';
@@ -8,10 +8,19 @@ import { type PrimaryConfig } from './primary-config.js';
 import type { RuntimeConfigDocument } from './config-composer.js';
 export type PluginConfigResolver = (node: PluginGraphNode) => unknown;
 export interface RootResourceContext {
+    readonly signal: AbortSignal;
     readonly resources: Scope;
     readonly lifecycle: DisposeStack;
     readonly handoff: GenerationHandoffRegistry;
+    /** Candidate-wide gate atomically switched by SnapshotStore at commit. */
+    readonly admission: GenerationAdmissionGate;
     readonly config: PrimaryConfig;
+    /**
+     * Adds a root-owned capability to this shadow generation. The definition is
+     * validated and projected with convention/setup capabilities; it is never
+     * visible before the generation commits.
+     */
+    addFeature<TDefinition>(feature: FeatureId | string, localName: string, definition: TDefinition): void;
 }
 export type RootResourceInstaller = (context: RootResourceContext) => void | Promise<void>;
 export interface PluginAssemblySeed {
@@ -36,7 +45,7 @@ export declare class PluginScopeAssembler {
     constructor(modules: ModuleRuntime, configResolver: PluginConfigResolver, environment: RuntimeEnvironment, primaryConfigDocument: RuntimeConfigDocument, installResources?: RootResourceInstaller | undefined, environmentLayers?: EnvironmentLayers, seed?: PluginAssemblySeed, isolation?: IsolatedPluginRuntimePort | undefined);
     removeSubtrees(roots: readonly PluginId[]): void;
     installSetupFeatureAliases(aliases: ReadonlyMap<string, FeatureId>): void;
-    setupTree(node: PluginGraphNode): Promise<void>;
+    setupTree(node: PluginGraphNode, signal: AbortSignal): Promise<void>;
     synchronizeTree(node: PluginGraphNode): void;
     createdScopeDisposers(): readonly (readonly [PluginId, Dispose])[];
     generationHandoff(): GenerationHandoff | undefined;

package/lib/plugin-scope-assembler.js

@@ -1,5 +1,5 @@
 import { resolve } from 'node:path';
-import { GenerationHandoffStack, Scope, capabilityId, createPluginDatabaseHost, createPluginScheduleHost, databaseHostToken, databaseRootHostToken, featureId, rootPluginId, scheduleHostToken, scheduleRootHostToken, unwrapPluginDatabaseHost, unwrapPluginScheduleHost, } from '@zhin.js/plugin-runtime';
+import { GenerationHandoffStack, Scope, capabilityId, createGenerationAdmissionGate, createToken, createPluginDatabaseHost, createPluginScheduleHost, databaseHostToken, databaseRootHostToken, featureId, rootPluginId, scheduleHostToken, scheduleRootHostToken, unwrapPluginDatabaseHost, unwrapPluginScheduleHost, } from '@zhin.js/plugin-runtime';
 import { runtimeEnvironmentToken } from './environment.js';
 import { EnvStoreFactory, envStoreToken, } from './environment-store.js';
 import { createPrimaryConfig, primaryConfigToken, } from './primary-config.js';
@@ -18,6 +18,7 @@ export class PluginScopeAssembler {
     #setupCapabilities = new Map();
     #created = [];
     #handoffs = new GenerationHandoffStack();
+    #admission = createGenerationAdmissionGate();
     #envStores;
     #setupFeatureAliases = new Map();
     constructor(modules, configResolver, environment, primaryConfigDocument, installResources, environmentLayers = {}, seed, isolation) {
@@ -48,7 +49,8 @@ export class PluginScopeAssembler {
     installSetupFeatureAliases(aliases) {
         this.#setupFeatureAliases = new Map(aliases);
     }
-    async setupTree(node) {
+    async setupTree(node, signal) {
+        signal.throwIfAborted();
         const manifest = node.package.packageJson.zhin;
         const parentScope = node.parent ? this.scopes.get(node.parent) : undefined;
         if (node.parent && !parentScope)
@@ -59,15 +61,20 @@ export class PluginScopeAssembler {
         // Every owner shadows the inherited EnvStore with its exact overlay view.
         const environment = this.#envStores.create(node.id);
         scope.provide(envStoreToken, environment);
+        const register = (feature, localName, capabilityDefinition) => this.#registerSetupCapability(node, manifest, feature, localName, capabilityDefinition);
         if (!node.parent) {
             scope.provide(runtimeEnvironmentToken, this.environment);
+            scope.provide(rootGenerationAdmissionToken, this.#admission);
             const config = createPrimaryConfig(this.primaryConfigDocument, environment);
             scope.provide(primaryConfigToken, config);
             await this.installResources?.({
+                signal,
                 resources: scope,
                 lifecycle: scope.disposers,
                 handoff: this.#handoffs,
+                admission: this.#admission,
                 config,
+                addFeature: register,
             });
         }
         if (node.parent)
@@ -98,7 +105,8 @@ export class PluginScopeAssembler {
                 entry: resolve(node.package.root, manifest.entry),
                 config,
                 environment: this.environment,
-            });
+            }, signal);
+            signal.throwIfAborted();
             // Ownership transfers to the shadow Scope immediately. Every later
             // validation or binding failure is then covered by normal rollback.
             scope.disposers.add(prepared.dispose);
@@ -114,6 +122,7 @@ export class PluginScopeAssembler {
         }
         else {
             const module = await this.modules.load(resolve(node.package.root, manifest.entry));
+            signal.throwIfAborted();
             const definition = module.default;
             if (!definition || typeof definition.name !== 'string') {
                 throw new TypeError(`${node.package.name} does not default-export a Plugin definition`);
@@ -123,22 +132,8 @@ export class PluginScopeAssembler {
                     throw new Error(`Missing resource ${token.id} for Plugin ${node.id}`);
                 }
             }
-            const register = (feature, localName, capabilityDefinition) => {
-                const featureName = featureId(String(feature));
-                const id = capabilityId(node.id, featureName, localName);
-                if (this.#setupCapabilities.has(id)) {
-                    throw new Error(`Duplicate setup Capability: ${id}`);
-                }
-                this.#setupCapabilities.set(id, Object.freeze({
-                    id,
-                    owner: node.id,
-                    feature: featureName,
-                    localName,
-                    source: resolve(node.package.root, manifest.entry),
-                    definition: capabilityDefinition,
-                }));
-            };
             const setupContext = {
+                signal,
                 plugin,
                 config: view,
                 resources: scope,
@@ -150,6 +145,7 @@ export class PluginScopeAssembler {
                 setupContext[method] = (name, value) => register(feature, name, value);
             }
             const returned = await definition.setup?.(Object.freeze(setupContext));
+            signal.throwIfAborted();
             if (returned)
                 scope.disposers.add(returned);
             metadata = definition.metadata;
@@ -167,7 +163,22 @@ export class PluginScopeAssembler {
         this.config.set(node.id, config);
         this.resources.set(node.id, scope.snapshot());
         for (const child of node.children)
-            await this.setupTree(child);
+            await this.setupTree(child, signal);
+    }
+    #registerSetupCapability(node, manifest, feature, localName, definition) {
+        const featureName = featureId(String(feature));
+        const id = capabilityId(node.id, featureName, localName);
+        if (this.#setupCapabilities.has(id)) {
+            throw new Error(`Duplicate setup Capability: ${id}`);
+        }
+        this.#setupCapabilities.set(id, Object.freeze({
+            id,
+            owner: node.id,
+            feature: featureName,
+            localName,
+            source: resolve(node.package.root, manifest.entry),
+            definition,
+        }));
     }
     synchronizeTree(node) {
         const current = this.tree.get(node.id);
@@ -222,6 +233,7 @@ export class PluginScopeAssembler {
         }
     }
 }
+const rootGenerationAdmissionToken = createToken('zhin.runtime.root-generation-admission');
 function isWithin(plugin, root) {
     return plugin === root || plugin.startsWith(`${root}/`);
 }

package/lib/root-runtime.d.ts

@@ -1,4 +1,4 @@
-import { RootController, type ControlErrorHandler, type PluginId, type RuntimeSnapshot } from '@zhin.js/plugin-runtime';
+import { type ControlErrorHandler, type GenerationCommitListener, type PluginId, type RuntimeSnapshot, type SnapshotReader } from '@zhin.js/plugin-runtime';
 import { type RuntimeConfigDocument } from './config-composer.js';
 import { type ConfigDocumentPort } from './config-document.js';
 import { type ConfigPatch } from './config-patch-planner.js';
@@ -24,9 +24,10 @@ export interface RootRuntimeOptions {
 export type RootHmrOptions = Omit<HmrCoordinatorOptions, 'modules' | 'ownership' | 'runtime'>;
 export declare class RootRuntime {
     #private;
-    readonly controller: RootController;
     constructor(options: RootRuntimeOptions);
     get snapshot(): RuntimeSnapshot;
+    get snapshots(): SnapshotReader;
+    onGenerationCommit(listener: GenerationCommitListener): () => void;
     get sourceOwnership(): SourceOwnershipIndex;
     start(): Promise<RuntimeSnapshot>;
     reload(target?: PluginId | string): Promise<RuntimeSnapshot>;

package/lib/root-runtime.js

@@ -23,7 +23,6 @@ import { SubtreeGenerationPreparer, SubtreeTopologyChangedError, } from './subtr
 import { TopologyGenerationPreparer } from './topology-generation-preparer.js';
 import { RestartBoundaryPlanner } from './restart-boundary.js';
 export class RootRuntime {
-    controller;
     #projectRoot;
     #modules;
     #environment;
@@ -37,6 +36,8 @@ export class RootRuntime {
     #ownership = SourceOwnershipIndex.empty();
     #model;
     #configPatchTail = Promise.resolve();
+    #stopResult;
+    #controller;
     constructor(options) {
         this.#projectRoot = resolve(options.projectRoot);
         this.#modules = options.modules;
@@ -50,10 +51,16 @@ export class RootRuntime {
             this.#configDocument = structuredClone(options.config ?? {});
         this.#installResources = options.installResources;
         this.#isolation = options.isolation;
-        this.controller = new RootController(emptyState(), options.onControlError);
+        this.#controller = new RootController(emptyState(), options.onControlError);
     }
     get snapshot() {
-        return this.controller.snapshots.current;
+        return this.#controller.snapshot;
+    }
+    get snapshots() {
+        return this.#controller.snapshots;
+    }
+    onGenerationCommit(listener) {
+        return this.#controller.onGenerationCommit(listener);
     }
     get sourceOwnership() {
         return this.#ownership;
@@ -65,8 +72,8 @@ export class RootRuntime {
             this.#configDocument = structuredClone(snapshot.document);
         }
         let prepared;
-        const snapshot = await this.controller.start(async (current) => {
-            prepared = await this.#prepare(current);
+        const snapshot = await this.#controller.start(async (current, signal) => {
+            prepared = await this.#prepare(current, signal);
             return prepared.generation;
         });
         this.#accept(requirePrepared(prepared));
@@ -74,8 +81,8 @@ export class RootRuntime {
     }
     async reload(target = rootPluginId()) {
         let prepared;
-        const snapshot = await this.controller.reload(target, async (current) => {
-            prepared = await this.#prepare(current);
+        const snapshot = await this.#controller.reload(target, async (current, signal) => {
+            prepared = await this.#prepare(current, signal);
             return prepared.generation;
         });
         this.#accept(requirePrepared(prepared));
@@ -103,18 +110,24 @@ export class RootRuntime {
     createProcessRestartExecutor(adapter) {
         return new RootProcessRestartExecutor(this, adapter);
     }
-    async stop() {
-        try {
-            await this.controller.stop();
-        }
-        finally {
-            await this.#modules.close();
-        }
+    stop() {
+        if (this.#stopResult)
+            return this.#stopResult;
+        const result = (async () => {
+            try {
+                await this.#controller.stop();
+            }
+            finally {
+                await this.#modules.close();
+            }
+        })();
+        this.#stopResult = result;
+        return result;
     }
     async #reloadPlan(plan) {
         let prepared;
         let restart;
-        const snapshot = await this.controller.reload(plan.subtrees[0] ?? plan.slots[0] ?? rootPluginId(), async (current) => {
+        const snapshot = await this.#controller.reload(plan.subtrees[0] ?? plan.slots[0] ?? rootPluginId(), async (current, signal) => {
             const resolved = await this.#resolveCapabilityDelta(current, plan);
             const effective = resolved.plan;
             if (this.#model && effective.manifestSources.length > 0) {
@@ -123,19 +136,19 @@ export class RootRuntime {
                 if (restart)
                     return undefined;
                 prepared = effective.subtrees.includes(rootPluginId())
-                    ? await this.#prepareInspected(current, inspected)
-                    : await new TopologyGenerationPreparer(this.#modules, this.#model, inspected.graph, inspected.configResolver, inspected.primaryConfigDocument, this.#environment, this.#installResources, this.#environmentLayers, this.#isolation).prepare(current, { ...effective, capabilities: resolved.capabilities });
+                    ? await this.#prepareInspected(current, inspected, signal)
+                    : await new TopologyGenerationPreparer(this.#modules, this.#model, inspected.graph, inspected.configResolver, inspected.primaryConfigDocument, this.#environment, this.#installResources, this.#environmentLayers, this.#isolation).prepare(current, signal, { ...effective, capabilities: resolved.capabilities });
             }
             else if (effective.subtrees.length === 0 && resolved.capabilities.size > 0 && this.#model) {
                 prepared = await new SlotGenerationPreparer(this.#modules, this.#model)
-                    .prepare(current, resolved.capabilities);
+                    .prepare(current, resolved.capabilities, signal);
             }
             else if (this.#model && this.#canPrepareSubtrees(effective)) {
                 const inspected = await this.#inspectProject();
-                prepared = await this.#prepareSubtrees(current, inspected, effective.subtrees);
+                prepared = await this.#prepareSubtrees(current, inspected, effective.subtrees, signal);
             }
             else {
-                prepared = await this.#prepare(current);
+                prepared = await this.#prepare(current, signal);
             }
             return prepared?.generation;
         });
@@ -176,8 +189,11 @@ export class RootRuntime {
             return records.length > 0 && records.every((record) => record.role === 'plugin' || record.role === 'schema');
         });
     }
-    async #prepare(current) {
-        return this.#prepareInspected(current, await this.#inspectProject());
+    async #prepare(current, signal) {
+        signal.throwIfAborted();
+        const inspected = await this.#inspectProject();
+        signal.throwIfAborted();
+        return this.#prepareInspected(current, inspected, signal);
     }
     async #inspectProject() {
         const resolver = await NodePackageResolver.create(this.#projectRoot);
@@ -234,7 +250,8 @@ export class RootRuntime {
         let prepared;
         let documentTransaction;
         let committedDocument;
-        const snapshot = await this.controller.reload(rootPluginId(), async (current) => {
+        const snapshot = await this.#controller.reload(rootPluginId(), async (current, signal) => {
+            signal.throwIfAborted();
             const resolver = await NodePackageResolver.create(this.#projectRoot);
             const graph = await new ProjectGraphService(resolver).inspect(this.#projectRoot);
             const planned = await new ConfigPatchPlanner().plan(graph, currentDocument, patches);
@@ -269,10 +286,10 @@ export class RootRuntime {
                 // when present so a committed patch cannot leave Host services on the
                 // previous generation's document.
                 if (!this.#installResources && this.#model && !planned.roots.includes(rootPluginId())) {
-                    prepared = await this.#prepareSubtrees(current, inspected, planned.roots);
+                    prepared = await this.#prepareSubtrees(current, inspected, planned.roots, signal);
                 }
                 else {
-                    prepared = await this.#prepareInspected(current, inspected);
+                    prepared = await this.#prepareInspected(current, inspected, signal);
                 }
                 return documentTransaction
                     ? withConfigDocumentHandoff(prepared.generation, documentTransaction, (committed) => { committedDocument = committed; })
@@ -295,20 +312,20 @@ export class RootRuntime {
             this.#configSnapshot = committedDocument;
         return snapshot;
     }
-    #prepareInspected(current, inspected) {
+    #prepareInspected(current, inspected, signal) {
         const assembler = new GenerationAssembler(inspected.graph, this.#modules, inspected.configResolver, inspected.primaryConfigDocument, current.generation + 1, this.#environment, this.#installResources, this.#environmentLayers, this.#isolation);
-        return assembler.prepare();
+        return assembler.prepare(signal);
     }
-    async #prepareSubtrees(current, inspected, roots) {
+    async #prepareSubtrees(current, inspected, roots, signal) {
         if (!this.#model)
-            return this.#prepareInspected(current, inspected);
+            return this.#prepareInspected(current, inspected, signal);
         try {
-            return await new SubtreeGenerationPreparer(this.#modules, this.#model, inspected.graph, inspected.configResolver, inspected.primaryConfigDocument, this.#environment, this.#installResources, this.#environmentLayers, this.#isolation).prepare(current, roots);
+            return await new SubtreeGenerationPreparer(this.#modules, this.#model, inspected.graph, inspected.configResolver, inspected.primaryConfigDocument, this.#environment, this.#installResources, this.#environmentLayers, this.#isolation).prepare(current, roots, signal);
         }
         catch (error) {
             if (!(error instanceof SubtreeTopologyChangedError))
                 throw error;
-            return this.#prepareInspected(current, inspected);
+            return this.#prepareInspected(current, inspected, signal);
         }
     }
 }
@@ -326,8 +343,10 @@ function withConfigDocumentHandoff(generation, document, committed) {
     // File commit follows Resource activation, so reverse compensation restores
     // the document before it deactivates the shadow generation.
     handoffs.add({
-        async activateNext() {
+        async activateNext(signal) {
+            signal.throwIfAborted();
             committed(await document.commit());
+            signal.throwIfAborted();
         },
         deactivateNext: () => document.rollback(),
     });
@@ -389,16 +408,17 @@ class GenerationAssembler {
         this.#host = new NodeDiscoveryHost(modules);
         this.#plugins = new PluginScopeAssembler(modules, configResolver, environment, primaryConfigDocument, installResources, environmentLayers, undefined, isolation);
     }
-    async prepare() {
+    async prepare(signal) {
+        signal.throwIfAborted();
         try {
             // Prepare is deliberately ordered: providers define discovery, setup
             // creates owner scopes, then definitions can be projected against both.
-            await this.#loadProviders(this.graph.root);
+            await this.#loadProviders(this.graph.root, signal);
             this.#plugins.installSetupFeatureAliases(featureSetupAliases(this.#catalog.values()));
-            await this.#plugins.setupTree(this.graph.root);
-            await this.#discover();
+            await this.#plugins.setupTree(this.graph.root, signal);
+            await this.#discover(signal);
             const projected = await new FeatureProjector(this.#catalog.values())
-                .project(this.generation, this.#projectionState());
+                .project(this.generation, this.#projectionState(), signal);
             for (const [feature, dispose] of projected.disposers) {
                 this.#projectionDisposers.set(feature, dispose);
             }
@@ -431,10 +451,12 @@ class GenerationAssembler {
             throw error;
         }
     }
-    async #loadProviders(node) {
+    async #loadProviders(node, signal) {
+        signal.throwIfAborted();
         for (const requirement of node.features) {
             const manifest = requirement.package.packageJson.zhin;
             const module = await this.modules.load(resolve(requirement.package.root, manifest.entry));
+            signal.throwIfAborted();
             const provider = module.default;
             if (!provider || provider.protocol !== 1) {
                 throw new TypeError(`${requirement.package.name} does not default-export a Feature provider`);
@@ -451,14 +473,16 @@ class GenerationAssembler {
             this.#rootsByFeature.set(provider.id, roots);
         }
         for (const child of node.children)
-            await this.#loadProviders(child);
+            await this.#loadProviders(child, signal);
     }
-    async #discover() {
+    async #discover(signal) {
         mergeSetupCapabilities(this.#capabilities, this.#plugins.setupCapabilities(), new Map(this.#catalog.values().map((provider) => [provider.id, provider])), this.#rootsByFeature);
         const discovery = new FeatureDiscovery(this.#host);
         for (const provider of this.#catalog.values()) {
+            signal.throwIfAborted();
             const roots = this.#rootsByFeature.get(provider.id) ?? [];
             const slots = await discovery.discover(provider, roots);
+            signal.throwIfAborted();
             for (const slot of slots)
                 addCapabilitySlot(this.#capabilities, slot);
         }

package/lib/slot-generation-preparer.d.ts

@@ -6,5 +6,5 @@ export declare class SlotGenerationPreparer {
     private readonly modules;
     private readonly model;
     constructor(modules: ModuleRuntime, model: RuntimeGenerationModel);
-    prepare(current: RuntimeSnapshot, selected: readonly CapabilityId[] | CapabilityDelta): Promise<PreparedRuntimeGeneration>;
+    prepare(current: RuntimeSnapshot, selected: readonly CapabilityId[] | CapabilityDelta, signal: AbortSignal): Promise<PreparedRuntimeGeneration>;
 }

package/lib/slot-generation-preparer.js

@@ -11,7 +11,8 @@ export class SlotGenerationPreparer {
         this.modules = modules;
         this.model = model;
     }
-    async prepare(current, selected) {
+    async prepare(current, selected, signal) {
+        signal.throwIfAborted();
         const selectedByFeature = Array.isArray(selected)
             ? capabilityDeltaFromSlots(current, selected)
             : selected;
@@ -24,6 +25,7 @@ export class SlotGenerationPreparer {
             for (const id of ids)
                 capabilities.delete(id);
             const replacements = await discovery.discover(provider, this.model.rootsByFeature.get(feature) ?? [], { capabilities: ids });
+            signal.throwIfAborted();
             for (const slot of replacements)
                 capabilities.set(slot.id, slot);
         }
@@ -41,7 +43,7 @@ export class SlotGenerationPreparer {
             config: current.config,
             resources: current.resources,
             capabilities,
-        }, current.projections);
+        }, signal, current.projections);
         try {
             const snapshot = createSnapshotView(current.generation + 1, projected.state);
             const ownership = SourceOwnershipIndex.fromGeneration(this.model.graph, snapshot, this.model.featureIdsByPackageRoot);

package/lib/subtree-generation-preparer.d.ts

@@ -22,5 +22,5 @@ export declare class SubtreeGenerationPreparer {
     private readonly environmentLayers;
     private readonly isolation?;
     constructor(modules: ModuleRuntime, model: RuntimeGenerationModel, graph: ProjectGraph, configResolver: PluginConfigResolver, primaryConfigDocument: RuntimeConfigDocument, environment: RuntimeEnvironment, installResources?: RootResourceInstaller | undefined, environmentLayers?: EnvironmentLayers, isolation?: IsolatedPluginRuntimePort | undefined);
-    prepare(current: RuntimeSnapshot, roots: readonly PluginId[]): Promise<PreparedRuntimeGeneration>;
+    prepare(current: RuntimeSnapshot, roots: readonly PluginId[], signal: AbortSignal): Promise<PreparedRuntimeGeneration>;
 }

package/lib/subtree-generation-preparer.js

@@ -33,7 +33,8 @@ export class SubtreeGenerationPreparer {
         this.environmentLayers = environmentLayers;
         this.isolation = isolation;
     }
-    async prepare(current, roots) {
+    async prepare(current, roots, signal) {
+        signal.throwIfAborted();
         const nodes = indexGraph(this.graph);
         assertCompatibleTopology(indexGraph(this.model.graph), nodes, roots);
         const plugins = new PluginScopeAssembler(this.modules, this.configResolver, this.environment, this.primaryConfigDocument, this.installResources, this.environmentLayers, {
@@ -50,7 +51,7 @@ export class SubtreeGenerationPreparer {
                 const node = nodes.get(root);
                 if (!node)
                     throw new SubtreeTopologyChangedError(`Missing subtree root: ${root}`);
-                await plugins.setupTree(node);
+                await plugins.setupTree(node, signal);
             }
             const capabilities = new Map(current.capabilities);
             for (const [id, slot] of capabilities) {
@@ -65,6 +66,7 @@ export class SubtreeGenerationPreparer {
                 if (affectedRoots.length === 0)
                     continue;
                 const slots = await discovery.discover(provider, affectedRoots);
+                signal.throwIfAborted();
                 for (const slot of slots)
                     addCapabilitySlot(capabilities, slot);
             }
@@ -74,7 +76,7 @@ export class SubtreeGenerationPreparer {
                 config: plugins.config,
                 resources: plugins.resources,
                 capabilities,
-            });
+            }, signal);
             for (const [feature, dispose] of projected.disposers) {
                 projectionDisposers.set(feature, dispose);
             }

package/lib/topology-generation-preparer.d.ts

@@ -27,5 +27,5 @@ export declare class TopologyGenerationPreparer {
     private readonly environmentLayers;
     private readonly isolation?;
     constructor(modules: ModuleRuntime, model: RuntimeGenerationModel, graph: ProjectGraph, configResolver: PluginConfigResolver, primaryConfigDocument: RuntimeConfigDocument, environment: RuntimeEnvironment, installResources?: RootResourceInstaller | undefined, environmentLayers?: EnvironmentLayers, isolation?: IsolatedPluginRuntimePort | undefined);
-    prepare(current: RuntimeSnapshot, delta?: TopologyRuntimeDelta): Promise<PreparedRuntimeGeneration | undefined>;
+    prepare(current: RuntimeSnapshot, signal: AbortSignal, delta?: TopologyRuntimeDelta): Promise<PreparedRuntimeGeneration | undefined>;
 }

package/lib/topology-generation-preparer.js

@@ -31,7 +31,8 @@ export class TopologyGenerationPreparer {
         this.environmentLayers = environmentLayers;
         this.isolation = isolation;
     }
-    async prepare(current, delta = { slots: [], subtrees: [] }) {
+    async prepare(current, signal, delta = { slots: [], subtrees: [] }) {
+        signal.throwIfAborted();
         const planned = new TopologyTransactionPlanner().plan(this.model.graph, this.graph);
         const nextNodes = graphNodes(this.graph);
         const configReplacements = changedConfigRoots(current, nextNodes, this.configResolver);
@@ -69,7 +70,7 @@ export class TopologyGenerationPreparer {
                 const node = nextNodes.get(root);
                 if (!node)
                     throw new Error(`Missing topology setup root: ${root}`);
-                await plugins.setupTree(node);
+                await plugins.setupTree(node, signal);
             }
             // Retained parents still need a new immutable children view after add,
             // remove, move, or reorder operations.
@@ -82,7 +83,7 @@ export class TopologyGenerationPreparer {
                 config: plugins.config,
                 resources: plugins.resources,
                 capabilities,
-            });
+            }, signal);
             for (const [feature, dispose] of projected.disposers) {
                 projectionDisposers.set(feature, dispose);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/runtime",
-  "version": "1.0.7",
+  "version": "1.0.10",
   "description": "Static Plugin graph, generation transaction and HMR Root runtime for Zhin.js",
   "type": "module",
   "main": "./lib/index.js",
@@ -18,22 +18,22 @@
   "dependencies": {
     "ajv": "8.18.0",
     "semver": "7.8.5",
-    "@zhin.js/feature-kit": "1.0.6",
-    "@zhin.js/plugin-runtime": "1.1.3"
+    "@zhin.js/feature-kit": "1.0.9",
+    "@zhin.js/plugin-runtime": "1.1.6"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",
     "typescript": "^6.0.3",
-    "@zhin.js/adapter": "1.1.5",
-    "@zhin.js/agent-feature": "1.0.6",
-    "@zhin.js/command": "1.0.7",
-    "@zhin.js/component": "1.0.6",
-    "@zhin.js/layout": "1.0.6",
-    "@zhin.js/mcp-feature": "1.0.6",
-    "@zhin.js/middleware": "1.0.6",
-    "@zhin.js/page": "1.0.6",
-    "@zhin.js/skill": "1.0.6",
-    "@zhin.js/tool": "1.0.6"
+    "@zhin.js/adapter": "1.1.8",
+    "@zhin.js/agent-feature": "1.0.9",
+    "@zhin.js/command": "1.0.12",
+    "@zhin.js/component": "1.0.9",
+    "@zhin.js/layout": "1.0.9",
+    "@zhin.js/mcp-feature": "1.0.9",
+    "@zhin.js/page": "1.0.9",
+    "@zhin.js/middleware": "1.0.9",
+    "@zhin.js/skill": "1.0.9",
+    "@zhin.js/tool": "1.0.9"
   },
   "repository": {
     "type": "git",