@plurnk/plurnk-service 3.2.0 → 4.0.0

package/dist/server/Functionality.js

@@ -1,4 +1,3 @@
-var _a;
 // {§functionality-coordinator} — the one owner of the workspace Functionality
 // lifecycle above the family adapters (Agent Skills, MCP, outbound A2A). It owns
 // durable workspace state, lifecycle ordering, serialization, atomic
@@ -42,7 +41,7 @@ const discoverInput = ({ inputs, emptyListsAll }) => ({
 });
 const failure = (family, code, status, detail, extensions = {}) => new OperationFailureError(Results.failure("functionality", code, status, detail, {}, { family, ...extensions }));
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-class Functionality {
+export default class Functionality {
     #host;
     #adapters = new Map();
     #owners = new Set();
@@ -93,31 +92,40 @@ class Functionality {
                 throw new Error(`Functionality ${family} input has no property map.`);
             return { ...source, properties: { ...source.properties, ...scopeProperties } };
         };
-        const addInput = Object.freeze({
-            type: "object",
-            additionalProperties: false,
-            required: ["definition"],
-            properties: {
-                ...scopeProperties,
-                alias: { type: "string", minLength: 1 },
-                definition: adapter.definitionSchema,
-            },
-        });
+        // {§functionality-addressing} — a family that names definitions by their content supplies the
+        // inputs of add and of the select verbs itself, and serves no replace.
+        const { addressing } = adapter;
+        if (addressing !== undefined && [addressing.add, addressing.select].some((schema) => !isRecord(schema) || !isRecord(schema.properties))) {
+            throw new Error(`Functionality family '${family}' declares addressing without object input schemas.`);
+        }
+        const addInput = addressing === undefined
+            ? Object.freeze({
+                type: "object",
+                additionalProperties: false,
+                required: ["definition"],
+                properties: {
+                    ...scopeProperties,
+                    alias: { type: "string", minLength: 1 },
+                    definition: adapter.definitionSchema,
+                },
+            })
+            : scopedInput(addressing.add);
+        const selectInput = scopedInput(addressing?.select ?? ALIAS_INPUT);
         // {§functionality-discover-advertisement} A family without discovery has no discover verb.
         const schemas = Object.freeze({
             list: scopedInput(EMPTY_INPUT),
             ...(discovery === undefined ? {} : { discover: scopedInput(discoverInput(discovery)) }),
             add: addInput,
-            replace: { ...addInput, required: ["alias", "definition"] },
-            enable: scopedInput(ALIAS_INPUT),
-            disable: scopedInput(ALIAS_INPUT),
-            remove: scopedInput(ALIAS_INPUT),
+            ...(addressing === undefined ? { replace: { ...addInput, required: ["alias", "definition"] } } : {}),
+            enable: selectInput,
+            disable: selectInput,
+            remove: selectInput,
         });
         // {§functionality-model-projection} — the taught `add` example must satisfy the schema it teaches.
         if (adapter.example !== undefined) {
             const example = Validator.validateJsonSchemaInstance(addInput, adapter.example);
             if (!example.valid) {
-                throw new Error(`Functionality family '${family}' teaches an add example that violates its own definition schema: ${JSON.stringify(example.errors)}`);
+                throw new Error(`Functionality family '${family}' teaches an add example that violates its own add input: ${JSON.stringify(example.errors)}`);
             }
         }
         this.#adapters.set(family, adapter);
@@ -144,7 +152,7 @@ class Functionality {
                             ? "FunctionalityDiscoverResult"
                             : "FunctionalityMutationResult"),
                     handler: async (params, context) => {
-                        if (context.scope === "worldless" || context.scope !== scope)
+                        if (context.scope === "daemon" || context.scope !== scope)
                             throw new Error(`${scope}.${family}.${verb} requires a ${scope}-scoped context.`);
                         const identity = context.scope === "worker"
                             ? { workspaceId: context.workspaceId, workerId: context.workerId, scope }
@@ -167,14 +175,16 @@ class Functionality {
     // `ifChanged` republishes only when the enabled definitions differ from the ones the resident
     // publication prepared ({§functionality-hotload}).
     async refresh(family, identity, options = {}) {
+        this.#host.signal.throwIfAborted();
         const adapter = this.#adapter(family);
         await this.#withWorkspaceGate(identity.workspaceId, adapter.namespaceOwner, options.gate ?? "wait", () => this.#serialize(this.#key(identity.workspaceId, family), async () => {
+            this.#host.signal.throwIfAborted();
             const current = this.#families.get(this.#key(identity.workspaceId, family));
             if (current === undefined)
                 return;
             if (options.ifChanged === true && current.configurationFailure === null) {
                 try {
-                    if (_a.#sameDefinitions(await this.#publishable(adapter, identity, current.state), current.enabled))
+                    if (Functionality.#sameDefinitions(await this.#publishable(adapter, identity, current.state), current.enabled))
                         return;
                 }
                 catch (cause) {
@@ -261,14 +271,21 @@ class Functionality {
         return out;
     }
     // The one lifecycle entry for both projections ({§functionality-model-mutation}).
-    async invoke(family, verb, params, identity, caller, options = {}) {
+    async invoke(family, verb, params, identity, caller, options = {}, signal = this.#host.signal) {
+        const lifetime = signal === this.#host.signal ? signal : AbortSignal.any([this.#host.signal, signal]);
+        lifetime.throwIfAborted();
+        const pending = this.#invoke(family, verb, params, identity, caller, options, lifetime);
+        this.#admissions.set(pending, identity.workspaceId);
         try {
-            return await this.#invoke(family, verb, params, identity, caller, options);
+            return await pending;
         }
         catch (cause) {
             if (!(cause instanceof ConfigurationError))
                 throw cause;
-            throw _a.#configurationFailure(family, cause);
+            throw Functionality.#configurationFailure(family, cause);
+        }
+        finally {
+            this.#admissions.delete(pending);
         }
     }
     static #configurationFailure(family, cause) {
@@ -279,7 +296,7 @@ class Functionality {
             recovery: "Correct the named configuration input. Other capabilities remain available.",
         }), { cause });
     }
-    async #invoke(family, verb, params, identity, caller, options) {
+    async #invoke(family, verb, params, identity, caller, options, signal) {
         const adapter = this.#adapter(family);
         const schema = this.#schemas.get(family)[verb];
         // Neither projection offers a verb the family does not serve ({§functionality-discover-advertisement}).
@@ -308,12 +325,19 @@ class Functionality {
         // Worker's own lane and take no workspace exclusivity: a Worker shapes its environment while
         // its siblings run.
         if (scope === "worker") {
-            const workerId = _a.#workerOf(adapter, identity);
-            return this.#serialize(`${this.#key(identity.workspaceId, family)}:${workerId}`, () => this.#invokeForWorker(adapter, verb, input, identity, workerId, caller, options));
+            const workerId = Functionality.#workerOf(adapter, identity);
+            return this.#serialize(`${this.#key(identity.workspaceId, family)}:${workerId}`, () => this.#invokeForWorker(adapter, verb, input, identity, workerId, caller, options, signal));
         }
         if (verb === "list")
             return { status: 200, body: await this.#list(adapter, identity) };
-        return this.#withWorkspaceGate(identity.workspaceId, adapter.namespaceOwner, caller === "operation" ? "wait" : "try", () => this.#serialize(this.#key(identity.workspaceId, family), () => this.#mutate(adapter, verb, input, identity, caller, options)));
+        const mutate = () => this.#serialize(this.#key(identity.workspaceId, family), () => this.#mutate(adapter, verb, input, identity, caller, options, signal));
+        // A context family (one that declares the worker scope) is read where it is used, so its workspace
+        // defaults change nothing resident either: they serialize on the family's lane, as a Worker's own do,
+        // and an operation inside its own held turn never waits on itself.
+        if (scopesOf(adapter).includes("worker"))
+            return mutate();
+        const publish = () => this.#withWorkspaceGate(identity.workspaceId, adapter.namespaceOwner, caller === "operation" ? "wait" : "try", mutate, signal);
+        return caller === "operation" ? this.#host.atWorkspaceBoundary(identity.workspaceId, publish) : publish();
     }
     // A worker-scoped verb that names no Worker is a defect at the projection, never a client
     // failure: both projections name the Worker ({§functionality-model-projection}).
@@ -342,8 +366,8 @@ class Functionality {
         this.#queues.set(key, next);
         return next;
     }
-    async #withWorkspaceGate(workspaceId, owner, gate, run) {
-        const pending = this.#host.withWorkspaceGate(workspaceId, owner, gate, run);
+    async #withWorkspaceGate(workspaceId, owner, gate, run, signal = this.#host.signal) {
+        const pending = this.#host.withWorkspaceGate(workspaceId, owner, gate, run, signal);
         this.#admissions.set(pending, workspaceId);
         try {
             return await pending;
@@ -355,6 +379,7 @@ class Functionality {
     async #activate(adapter, context) {
         const identity = { workspaceId: context.workspaceId };
         await this.#serialize(this.#key(identity.workspaceId, adapter.family), async () => {
+            this.#host.signal.throwIfAborted();
             const state = await this.#loadState(adapter, identity.workspaceId);
             await this.#publish(adapter, identity, state, { failure: "publish-unavailable", configurationFailure: "contain", retain: context.retain });
         });
@@ -370,10 +395,10 @@ class Functionality {
         });
     }
     async #loadState(adapter, workspaceId) {
-        return _a.#parseState(adapter, await this.#host.readWorkspaceModuleState(workspaceId, adapter.namespaceOwner), `workspace ${workspaceId}`, "workspace");
+        return Functionality.#parseState(adapter, await this.#host.readWorkspaceModuleState(workspaceId, adapter.namespaceOwner), `workspace ${workspaceId}`, "workspace");
     }
     async #loadWorkerState(adapter, workerId) {
-        return _a.#parseState(adapter, await this.#host.readWorkerModuleState(workerId, adapter.namespaceOwner), `worker ${workerId}`, "worker");
+        return Functionality.#parseState(adapter, await this.#host.readWorkerModuleState(workerId, adapter.namespaceOwner), `worker ${workerId}`, "worker");
     }
     static #parseState(adapter, raw, where, scope) {
         if (raw === null)
@@ -415,7 +440,7 @@ class Functionality {
     }
     async #effective(adapter, identity, state) {
         const effective = new Map();
-        const local = _a.#localOrigin(identity);
+        const local = Functionality.#localOrigin(identity);
         const inheritsWorkspace = identity.scope === "worker" && scopesOf(adapter).includes("workspace");
         const lower = inheritsWorkspace
             ? [...(await this.#effective(adapter, { workspaceId: identity.workspaceId, scope: "workspace" }, await this.#loadState(adapter, identity.workspaceId))).values()]
@@ -471,7 +496,7 @@ class Functionality {
         return Validator.assertFunctionalityListResult({
             family: adapter.family,
             definitions: [...effective.values()].map((definition) => {
-                const outcome = isDeepStrictEqual(family?.enabled.get(definition.alias), _a.#binding(definition))
+                const outcome = isDeepStrictEqual(family?.enabled.get(definition.alias), Functionality.#binding(definition))
                     ? outcomes?.get(definition.alias)
                     : undefined;
                 return this.#projection(definition, outcome ?? { state: "dormant" });
@@ -483,45 +508,66 @@ class Functionality {
         const candidates = await adapter.discover(query, identity, options);
         return Validator.assertFunctionalityDiscoverResult({ family: adapter.family, candidates: [...candidates] });
     }
+    // The alias a select verb names: the input's `alias`, or what an addressing family reads from its
+    // own select input ({§functionality-addressing}).
+    static #selected(adapter, input) {
+        return adapter.addressing === undefined ? input.alias : adapter.addressing.alias(input);
+    }
     // The verb semantics, one implementation for every family ({§functionality-scope}): the next
-    // state, the alias it concerns, and how the mutation reports. Only publication differs by scope.
+    // state, the aliases it concerns, and how the mutation reports. Only publication differs by scope.
     async #transition(adapter, verb, input, identity, caller, state, effective, options) {
-        const local = _a.#localOrigin(identity);
+        const local = Functionality.#localOrigin(identity);
         const here = local === "worker" ? "this worker" : "this workspace";
         const definitions = { ...state.definitions };
-        let alias;
+        const aliases = [];
         let status = 200;
         let removed = false;
-        let admission;
+        let admissions = [];
         switch (verb) {
             case "add":
             case "replace": {
                 const admitted = await adapter.admit(input, identity, caller, options);
-                admission = admitted;
-                alias = admitted.alias;
-                if (!aliasPattern(adapter).test(alias))
-                    throw failure(adapter.family, "alias-invalid", 400, `Alias '${alias}' must match ${aliasPattern(adapter)}.`, { alias, retryable: false });
-                const current = effective.get(alias);
-                if (verb === "add" && current?.origin === local && !isDeepStrictEqual(current.definition, admitted.definition)) {
-                    throw failure(adapter.family, "alias-exists", 409, `'${alias}' already has a different ${local} definition.`, { alias, recovery: "Use replace with the complete definition to change it.", retryable: false });
+                admissions = Array.isArray(admitted) ? [...admitted] : [admitted];
+                // {§functionality-addressing} — an alias family admits exactly one definition; an addressing
+                // family's add admits each the body names, and all of them or none.
+                if (adapter.addressing === undefined ? admissions.length !== 1 : admissions.length === 0) {
+                    throw new Error(`${adapter.family} admitted ${admissions.length} definitions for one ${verb}.`);
+                }
+                for (const admission of admissions) {
+                    const { alias } = admission;
+                    if (!aliasPattern(adapter).test(alias))
+                        throw failure(adapter.family, "alias-invalid", 400, `Alias '${alias}' must match ${aliasPattern(adapter)}.`, { alias, retryable: false });
+                    if (aliases.includes(alias))
+                        throw new Error(`${adapter.family} admitted '${alias}' twice in one ${verb}.`);
+                    const current = effective.get(alias);
+                    if (verb === "add" && current?.origin === local && !isDeepStrictEqual(current.definition, admission.definition)) {
+                        throw failure(adapter.family, "alias-exists", 409, `'${alias}' already has a different ${local} definition.`, {
+                            alias,
+                            recovery: adapter.addressing === undefined ? "Use replace with the complete definition to change it." : "Remove it, then add it again.",
+                            retryable: false,
+                        });
+                    }
+                    definitions[alias] = { origin: local, definition: admission.definition, enabled: verb === "replace" ? current?.enabled ?? true : true };
+                    if (current?.origin !== local)
+                        status = 201;
+                    aliases.push(alias);
                 }
-                definitions[alias] = { origin: local, definition: admitted.definition, enabled: verb === "replace" ? current?.enabled ?? true : true };
-                status = current?.origin === local ? 200 : 201;
                 break;
             }
             case "enable":
             case "disable": {
-                alias = input.alias;
+                const alias = Functionality.#selected(adapter, input);
                 const current = effective.get(alias);
                 if (current === undefined)
                     throw failure(adapter.family, "alias-unknown", 404, `'${alias}' is not available to ${here}.`, { alias, retryable: false });
                 definitions[alias] = current.origin === local
                     ? { origin: local, definition: current.definition, enabled: verb === "enable" }
                     : { origin: current.origin, enabled: verb === "enable" };
+                aliases.push(alias);
                 break;
             }
             case "remove": {
-                alias = input.alias;
+                const alias = Functionality.#selected(adapter, input);
                 const current = effective.get(alias);
                 if (current === undefined)
                     throw failure(adapter.family, "alias-unknown", 404, `'${alias}' is not available to ${here}.`, { alias, retryable: false });
@@ -532,25 +578,34 @@ class Functionality {
                 await adapter.forget?.({ alias, definition: current.definition }, identity);
                 delete definitions[alias];
                 removed = true;
+                aliases.push(alias);
                 break;
             }
             default: throw new Error(`unreachable verb ${verb}`);
         }
-        return { definitions, alias, status, removed, ...(admission === undefined ? {} : { admission }) };
+        return { definitions, aliases, status, removed, admissions };
     }
-    #mutationResult(adapter, { alias, status, removed }, effectiveAfter, outcomes) {
-        const definition = effectiveAfter.get(alias);
-        const projection = definition === undefined ? undefined : this.#projection(definition, outcomes.get(alias));
-        const body = Validator.assertFunctionalityMutationResult({
-            status: projection?.state === "authorization-required" ? 202 : status,
-            family: adapter.family,
-            alias,
-            ...(projection === undefined ? {} : { definition: projection }),
-            ...(removed ? { removed: true } : {}),
+    // {§functionality-mutation-status} — the receipt: the one alias a mutation concerned, or every
+    // definition an addressing family's add admitted ({§functionality-addressing}).
+    #mutationResult(adapter, verb, { aliases, status, removed }, effectiveAfter, outcomes) {
+        const projections = aliases.map((alias) => {
+            const definition = effectiveAfter.get(alias);
+            return definition === undefined ? undefined : this.#projection(definition, outcomes.get(alias));
         });
+        const authorization = projections.some((projection) => projection?.state === "authorization-required");
+        const body = Validator.assertFunctionalityMutationResult(adapter.addressing !== undefined && verb === "add"
+            ? { status: authorization ? 202 : status, family: adapter.family, definitions: projections.map((projection) => projection) }
+            : {
+                status: authorization ? 202 : status,
+                family: adapter.family,
+                alias: aliases[0],
+                ...(projections[0] === undefined ? {} : { definition: projections[0] }),
+                ...(removed ? { removed: true } : {}),
+            });
         return { status: body.status, body };
     }
-    async #mutate(adapter, verb, input, identity, caller, options) {
+    async #mutate(adapter, verb, input, identity, caller, options, signal) {
+        signal.throwIfAborted();
         const key = this.#key(identity.workspaceId, adapter.family);
         const family = this.#families.get(key);
         if (family === undefined)
@@ -560,25 +615,33 @@ class Functionality {
         const nextState = { version: STATE_VERSION, definitions: transition.definitions };
         // Re-enabling an alias that is not active retries its preparation; an
         // already-active alias keeps its live attachment.
-        const retry = verb === "enable" && family.prepared?.outcomes.get(transition.alias)?.state !== "active";
+        const retry = verb === "enable" && family.prepared?.outcomes.get(transition.aliases[0])?.state !== "active";
         const publication = await this.#publish(adapter, identity, nextState, {
             failure: caller === "action" || verb === "replace" ? "reject" : "publish-unavailable",
             configurationFailure: "reject",
             retain: () => this.#host.retainWorkspace(identity.workspaceId),
-            forceAlias: retry ? transition.alias : null,
-            admission: transition.admission,
+            forceAlias: retry ? transition.aliases[0] : null,
+            admissions: transition.admissions,
+            signal,
         });
         const effectiveAfter = await this.#effective(adapter, identity, nextState);
-        return this.#mutationResult(adapter, transition, effectiveAfter, publication.outcomes);
+        return this.#mutationResult(adapter, verb, transition, effectiveAfter, publication.outcomes);
     }
     // {§functionality-scope} — the Worker's own lane. State is read at each verb rather than held: the
     // spawn reads the same row, and a Worker's row is written at its creation, so nothing in memory
     // could be more current than the table.
-    async #invokeForWorker(adapter, verb, input, identity, workerId, caller, options) {
+    async #invokeForWorker(adapter, verb, input, identity, workerId, caller, options, signal) {
+        signal.throwIfAborted();
         const state = await this.#loadWorkerState(adapter, workerId);
         const effective = await this.#effective(adapter, identity, state);
         if (verb === "list") {
-            const prepared = await this.#prepareForWorker(adapter, identity, effective, "publish-unavailable");
+            const prepared = await this.#prepareForWorker(adapter, identity, effective, "publish-unavailable", [], signal);
+            try {
+                signal.throwIfAborted();
+            }
+            catch (cause) {
+                return Functionality.#abort(prepared, cause);
+            }
             await prepared.commit();
             return { status: 200, body: Validator.assertFunctionalityListResult({
                     family: adapter.family,
@@ -588,35 +651,35 @@ class Functionality {
         const transition = await this.#transition(adapter, verb, input, identity, caller, state, effective, options);
         const nextState = { version: STATE_VERSION, definitions: transition.definitions };
         const effectiveAfter = await this.#effective(adapter, identity, nextState);
-        const prepared = await this.#prepareForWorker(adapter, identity, effectiveAfter, caller === "action" || verb === "replace" ? "reject" : "publish-unavailable", transition.admission);
+        const prepared = await this.#prepareForWorker(adapter, identity, effectiveAfter, caller === "action" || verb === "replace" ? "reject" : "publish-unavailable", transition.admissions, signal);
         try {
-            await this.#host.replaceWorkerModuleState(workerId, adapter.namespaceOwner, _a.#persisted(nextState));
+            signal.throwIfAborted();
+            await this.#host.replaceWorkerModuleState(workerId, adapter.namespaceOwner, Functionality.#persisted(nextState));
         }
         catch (cause) {
-            return _a.#abort(prepared, cause);
+            return Functionality.#abort(prepared, cause);
         }
         await prepared.commit();
-        return this.#mutationResult(adapter, transition, effectiveAfter, prepared.outcomes);
+        return this.#mutationResult(adapter, verb, transition, effectiveAfter, prepared.outcomes);
     }
     // A worker-scoped family's preparation yields outcomes only. It holds no residency — no runtimes,
     // documents or snapshot ({§module-workspace-residency}) — because its definitions are read at the
     // spawn that uses them rather than leased and cooled; the coordinator enforces that here.
-    async #prepareForWorker(adapter, identity, effective, failureMode, admission) {
-        const enabled = _a.#enabled(effective);
-        const prepared = await adapter.prepare({
-            workspaceId: identity.workspaceId, enabled, previous: null, failure: failureMode,
-            ...(admission === undefined ? {} : { admission }),
+    async #prepareForWorker(adapter, identity, effective, failureMode, admissions = [], signal = this.#host.signal) {
+        const enabled = Functionality.#enabled(effective);
+        const prepared = await this.#prepare(adapter, {
+            workspaceId: identity.workspaceId, enabled, previous: null, failure: failureMode, admissions,
             progress: () => undefined,
             retain: () => this.#host.retainWorkspace(identity.workspaceId),
-        });
+        }, signal);
         try {
-            _a.#checkOutcomes(adapter, enabled, prepared);
+            Functionality.#checkOutcomes(adapter, enabled, prepared);
             if ((prepared.runtimes?.length ?? 0) > 0 || prepared.documents.length > 0 || prepared.snapshot !== null) {
                 throw new Error(`${adapter.family} is worker-scoped and holds no residency, yet its preparation published runtimes, documents or a snapshot.`);
             }
         }
         catch (cause) {
-            return _a.#abort(prepared, cause);
+            return Functionality.#abort(prepared, cause);
         }
         return prepared;
     }
@@ -626,7 +689,7 @@ class Functionality {
     async #publishable(adapter, identity, state) {
         if (!scopesOf(adapter).includes("workspace"))
             return new Map();
-        return _a.#enabled(await this.#effective(adapter, { ...identity, scope: "workspace" }, state));
+        return Functionality.#enabled(await this.#effective(adapter, { ...identity, scope: "workspace" }, state));
     }
     static #sameDefinitions(left, right) {
         if (left.size !== right.size)
@@ -644,7 +707,7 @@ class Functionality {
         const enabled = new Map();
         for (const definition of effective.values()) {
             if (definition.enabled)
-                enabled.set(definition.alias, structuredClone(_a.#binding(definition)));
+                enabled.set(definition.alias, structuredClone(Functionality.#binding(definition)));
         }
         return enabled;
     }
@@ -662,19 +725,36 @@ class Functionality {
         return [...(this.#preparations.get(workspaceId)?.values() ?? [])].map((activity) => ({ ...activity }));
     }
     async #publish(adapter, identity, nextState, options) {
+        (options.signal ?? this.#host.signal).throwIfAborted();
         const { workspaceId } = identity;
         const current = this.#preparations.get(workspaceId) ?? new Map();
         this.#preparations.set(workspaceId, current);
-        const report = (alias, phase) => {
-            current.set(adapter.family, { family: adapter.family, alias, phase, since: new Date().toISOString() });
+        const forget = () => {
+            for (const [key, activity] of current)
+                if (activity.family === adapter.family)
+                    current.delete(key);
+        };
+        // {§functionality-preparation-visibility} — one activity for the family, or one per alias it reports
+        // preparing, each keeping the time its alias began.
+        const report = (aliases, phase) => {
+            const now = new Date().toISOString();
+            const began = new Map([...current.values()]
+                .filter((activity) => activity.family === adapter.family && activity.alias !== null)
+                .map((activity) => [activity.alias, activity.since]));
+            forget();
+            if (aliases.length === 0)
+                current.set(adapter.family, { family: adapter.family, alias: null, phase, since: now });
+            for (const alias of aliases) {
+                current.set(`${adapter.family}/${alias}`, { family: adapter.family, alias, phase, since: began.get(alias) ?? now });
+            }
             this.#host.preparationChanged(workspaceId, this.preparationStatus(workspaceId));
         };
-        report(null, "preparing");
+        report([], "preparing");
         try {
             return await this.#publishPrepared(adapter, identity, nextState, options, report);
         }
         finally {
-            current.delete(adapter.family);
+            forget();
             if (current.size === 0)
                 this.#preparations.delete(workspaceId);
             this.#host.preparationChanged(workspaceId, this.preparationStatus(workspaceId));
@@ -682,6 +762,7 @@ class Functionality {
     }
     async #publishPrepared(adapter, identity, nextState, options, report) {
         const key = this.#key(identity.workspaceId, adapter.family);
+        const signal = options.signal ?? this.#host.signal;
         const previous = this.#families.get(key)?.prepared ?? null;
         let enabled = new Map();
         let prepared = null;
@@ -690,20 +771,23 @@ class Functionality {
         try {
             enabled = await this.#publishable(adapter, identity, nextState);
             phase = "preparation";
-            prepared = await adapter.prepare({
+            prepared = await this.#prepare(adapter, {
                 workspaceId: identity.workspaceId,
                 enabled,
                 previous: previous?.snapshot ?? null,
                 failure: options.failure,
-                ...(options.admission === undefined ? {} : { admission: options.admission }),
-                progress: (alias) => {
-                    if (!enabled.has(alias))
-                        throw new Error(`${adapter.family} reported preparation of unknown alias '${alias}'.`);
-                    report(alias, "preparing");
+                admissions: options.admissions ?? [],
+                progress: (aliases) => {
+                    signal.throwIfAborted();
+                    for (const alias of aliases) {
+                        if (!enabled.has(alias))
+                            throw new Error(`${adapter.family} reported preparation of unknown alias '${alias}'.`);
+                    }
+                    report(aliases, "preparing");
                 },
                 retain: options.retain,
                 ...(options.forceAlias ? { force: options.forceAlias } : {}),
-            });
+            }, signal);
         }
         catch (cause) {
             if (!(cause instanceof ConfigurationError) || options.configurationFailure === "reject")
@@ -711,11 +795,12 @@ class Functionality {
             configurationFailure = { phase, error: cause };
             enabled = new Map();
         }
-        report(null, "publishing");
         let runtimes;
         try {
+            signal.throwIfAborted();
+            report([], "publishing");
             if (prepared !== null)
-                _a.#checkOutcomes(adapter, enabled, prepared);
+                Functionality.#checkOutcomes(adapter, enabled, prepared);
             for (const runtime of prepared?.runtimes ?? []) {
                 if (runtime.namespaceOwner !== adapter.namespaceOwner) {
                     throw new Error(`${adapter.family} prepared a runtime owned by '${runtime.namespaceOwner}' instead of '${adapter.namespaceOwner}'.`);
@@ -736,15 +821,16 @@ class Functionality {
             runtimes = [manager, ...(prepared?.runtimes ?? [])];
         }
         catch (cause) {
-            return _a.#abort(prepared, cause);
+            return Functionality.#abort(prepared, cause);
         }
         const commit = async () => {
             const before = this.#families.get(key);
             try {
+                signal.throwIfAborted();
                 await this.#host.replaceWorkspaceCapabilities({
                     workspaceId: identity.workspaceId,
                     namespaceOwner: adapter.namespaceOwner,
-                    state: _a.#persisted(nextState),
+                    state: Functionality.#persisted(nextState),
                     runtimes,
                 }, {
                     gate: "none",
@@ -760,7 +846,7 @@ class Functionality {
                 });
             }
             catch (cause) {
-                return _a.#abort(prepared, cause);
+                return Functionality.#abort(prepared, cause);
             }
             if (prepared !== null)
                 await prepared.commit();
@@ -770,6 +856,18 @@ class Functionality {
         await commit();
         return { outcomes: prepared?.outcomes ?? new Map() };
     }
+    // {§functionality-preparation-cancellation} Join the adapter; abort a returned candidate before publication.
+    async #prepare(adapter, preparation, signal = this.#host.signal) {
+        signal.throwIfAborted();
+        const prepared = await adapter.prepare({ ...preparation, signal });
+        try {
+            signal.throwIfAborted();
+        }
+        catch (cause) {
+            return Functionality.#abort(prepared, cause);
+        }
+        return prepared;
+    }
     static async #abort(prepared, cause) {
         try {
             await prepared?.abort();
@@ -780,6 +878,4 @@ class Functionality {
         throw cause;
     }
 }
-_a = Functionality;
-export default Functionality;
 //# sourceMappingURL=Functionality.js.map