maka-agent 0.2.0-dev.62.20260928 → 0.2.0-dev.67.20261002

package/node_modules/@maka/runtime/dist/ai-sdk-compaction.js

@@ -132,7 +132,14 @@ export class AiSdkCompaction {
             if (previousCheckpoint) {
                 const match = matchHistoryCompactCheckpointPrefix(previousCheckpoint, runtimeContext);
                 if (!match.reason && match.successorRuntimeEvents.length === 0) {
-                    {
+                    // Raw identity is not enough: a projection transition committed
+                    // after the fold rewrites the covered span's effective view without
+                    // touching the raw ledger, so reuse requires the pinned effective
+                    // digest to still match — the same gate the pre-send path applies
+                    // (#5929). On drift, fall through to the planner, whose roll-forward
+                    // currency check discards the stale checkpoint and re-summarizes.
+                    const effectiveCovered = await this.foldEffectiveModelHistory(match.coveredRuntimeEvents);
+                    if (this.checkpointEffectiveCoverageMatches(previousCheckpoint, effectiveCovered)) {
                         const projectedEvents = projectHistoryCompactCheckpointReplay(previousCheckpoint, match.coveredRuntimeEvents, []);
                         return {
                             outcome: { kind: 'unchanged', reason: 'already_compacted' },
@@ -799,14 +806,21 @@ export class AiSdkCompaction {
         });
         if (plan.decision === 'fail_open') {
             const diagnosticReason = plan.diagnosticReason ?? plan.reason;
-            // Latch every fail-open reason, not only the malformed ones. The baseline
+            // Latch only a fail-open the summarizer actually produced. The baseline
             // that fired this trigger survives a fail-open, so without the latch the
             // next step evaluates the same condition and dispatches the same doomed
             // summarizer call: a provider that answers slowly and fails (kimi's HTTP
             // 200 with an error body) produced 15 such calls over 47 minutes before
             // one main request (#4634). The latch covers the whole Turn and only
             // fail-opens; a successful fold spends no part of it (#4559).
-            state.summarizerFailure = diagnosticReason;
+            //
+            // no_safe_completed_span is not a summarizer failure — no call was made.
+            // It describes the event pool at this step, and a pool that has since
+            // grown a completed tool pair can present a safe cut, so the next
+            // attempt must re-read the ledger rather than inherit this miss (#5790).
+            if (plan.reason === 'summarizer_failed') {
+                state.summarizerFailure = diagnosticReason;
+            }
             return {
                 decision: 'fail',
                 diagnosticReason,
@@ -1042,7 +1056,12 @@ export class MidTurnCapacityCompactState {
     flushedSteps = 0;
     /** Exact historical image results omitted after a provider overflow. */
     omittedImageToolResults = new Map();
-    /** Malformed summaries spend one bounded repair budget for this whole Turn. */
+    /**
+     * One bounded retry budget for the whole Turn, spent only by a failure the
+     * summarizer actually produced (#4634). A structural miss like
+     * no_safe_completed_span never reaches it: the pool may grow a safe cut, so
+     * the next attempt re-reads the ledger instead of short-circuiting (#5790).
+     */
     summarizerFailure;
     constructor(headAnchor, priorContentEvents, priorInvocations, 
     /**

package/node_modules/@maka/runtime/dist/ai-sdk-message-projection.js

@@ -24,6 +24,7 @@ import { admitProviderReasoningReplayItems, buildRuntimeEventReplayTimeline, for
 import { openAiChatReasoningFieldFromProviderOptions } from './openai-chat-reasoning-transport.js';
 import { decodePlaintextResponsesReasoningState, replayPlaintextResponsesProviderOptions, } from './responses-reasoning-state.js';
 import { toolResultOutput } from './tool-result-output.js';
+import { deepSeekWebSearchReplayItem, deepSeekWebSearchReplayOptions, } from './deepseek-web-search-codec.js';
 function isRedactedThinking(providerOptions) {
     const anthropic = providerOptions?.anthropic;
     return (!!anthropic &&
@@ -118,6 +119,7 @@ export class AiSdkMessageProjection {
     }
     canReplayProviderNative(plan) {
         const support = this.input.modelAdapter.runtimeEventReplaySupport();
+        const replayableDeepSeekPairs = this.replayableDeepSeekPairIds(plan);
         for (const item of plan.items) {
             if (item.kind === 'tool_call' && !support.toolCalls)
                 return false;
@@ -125,7 +127,8 @@ export class AiSdkMessageProjection {
                 return false;
             if ((item.kind === 'tool_call' || item.kind === 'tool_result') &&
                 item.providerExecuted === true &&
-                !support.providerExecutedTools) {
+                !support.providerExecutedTools &&
+                !replayableDeepSeekPairs.has(item.eventId)) {
                 return false;
             }
             if (item.kind === 'thinking' && item.signature && !support.signedThinking)
@@ -142,19 +145,38 @@ export class AiSdkMessageProjection {
      */
     dropUnsupportedReplayItems(plan) {
         const support = this.input.modelAdapter.runtimeEventReplaySupport();
+        const replayableDeepSeekPairs = this.replayableDeepSeekPairIds(plan);
         return {
             ...plan,
             items: plan.items.filter((item) => {
                 if (item.kind === 'tool_call' || item.kind === 'tool_result') {
                     if (!support.toolCalls || !support.toolResults)
                         return false;
-                    if (item.providerExecuted === true && !support.providerExecutedTools)
+                    if (item.providerExecuted === true &&
+                        !support.providerExecutedTools &&
+                        !replayableDeepSeekPairs.has(item.eventId))
                         return false;
                 }
                 return true;
             }),
         };
     }
+    replayableDeepSeekPairIds(plan) {
+        const ids = new Set();
+        if (!this.input.modelAdapter.supportsDeepSeekWebSearchReplay())
+            return ids;
+        for (const entry of buildRuntimeEventReplayTimeline(plan.items)) {
+            if (entry.kind !== 'assistant_step')
+                continue;
+            for (const { call, result } of entry.calls) {
+                if (result?.providerExecuted !== true || !deepSeekWebSearchReplayItem(call))
+                    continue;
+                ids.add(call.eventId);
+                ids.add(result.eventId);
+            }
+        }
+        return ids;
+    }
     /**
      * Materialize a replay plan into provider messages, grouping each assistant
      * step's reasoning + text + tool calls into ONE assistant message (Anthropic
@@ -310,12 +332,19 @@ export class AiSdkMessageProjection {
             for (const { call, result } of exchanges) {
                 if (call.providerExecuted !== true)
                     continue;
+                const deepSeekItem = result?.providerExecuted === true &&
+                    this.input.modelAdapter.supportsDeepSeekWebSearchReplay()
+                    ? deepSeekWebSearchReplayItem(call)
+                    : undefined;
+                const replayOptions = deepSeekItem
+                    ? deepSeekWebSearchReplayOptions(deepSeekItem)
+                    : call.providerOptions;
                 content.push({
                     type: 'tool-call',
                     toolCallId: call.toolCallId,
                     toolName: call.toolName,
                     input: call.input,
-                    ...(call.providerOptions !== undefined ? { providerOptions: call.providerOptions } : {}),
+                    ...(replayOptions !== undefined ? { providerOptions: replayOptions } : {}),
                     providerExecuted: true,
                 });
                 if (!result || result.providerExecuted !== true)
@@ -326,6 +355,7 @@ export class AiSdkMessageProjection {
                     toolCallId: result.toolCallId,
                     toolName: result.toolName,
                     output: await materializeReplayToolResult(result, call.toolName),
+                    ...(deepSeekItem ? { providerOptions: replayOptions } : {}),
                 });
             }
             if (text && text.content.length > 0) {

package/node_modules/@maka/runtime/dist/conversation-copy.js

@@ -529,6 +529,12 @@ export async function cloneConversationRuntimeLedger(input) {
             await input.runStore.appendEvent(input.referenceMap.targetSessionId, runId, clonedEvent);
         }
         if (plan.terminal.kind === 'fact' && terminalEvent) {
+            // The preflight rejects handoff lineage before a plan reaches cloning,
+            // so a handed-off run never gets here; the guard keeps the outcome type
+            // honest at the boundary.
+            if (plan.terminal.fact.runStatus === 'handed_off') {
+                throw new Error(`Copied AgentRun ${plan.run.runId} carries unresolved handoff lineage`);
+            }
             await commitTerminalRunWithRuntimeFact({
                 runtimeEventStore: input.runtimeEventStore,
                 newId: input.newId,

package/node_modules/@maka/runtime/dist/deepseek-web-search-codec.js

@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+const EXTENSION_ID = 'deepseek.web_search';
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function completedWebSearchItem(value) {
+    if (!isRecord(value) || value.type !== 'web_search_call' || value.status !== 'completed') {
+        return false;
+    }
+    return typeof value.id === 'string' && value.id.length > 0 && isRecord(value.action);
+}
+/** Only original, completed provider output is eligible for exact replay. */
+export function deepSeekWebSearchReplayItem(call) {
+    if (call.providerExecuted !== true || call.toolName !== 'WebSearch')
+        return undefined;
+    const deepseek = call.providerOptions?.deepseek;
+    const item = isRecord(deepseek) ? deepseek.makaWebSearchItem : undefined;
+    return completedWebSearchItem(item) && item.id === call.toolCallId ? item : undefined;
+}
+export function deepSeekWebSearchReplayOptions(item) {
+    return { deepseek: { openResponsesExtension: { id: EXTENSION_ID, item } } };
+}
+/**
+ * Decode historical DeepSeek Responses web search output. Current DeepSeek
+ * models ignore built-in web_search; this codec declares no outgoing tool.
+ */
+export const deepSeekWebSearchCodec = {
+    id: EXTENSION_ID,
+    allowBareTypes: true,
+    bareItemTypes: ['web_search_call'],
+    decodeItem: ({ item }) => {
+        if (!completedWebSearchItem(item))
+            return undefined;
+        return [
+            {
+                type: 'tool-call',
+                toolCallId: item.id,
+                toolName: 'WebSearch',
+                input: JSON.stringify(item.action),
+                providerExecuted: true,
+                providerMetadata: { deepseek: { makaWebSearchItem: item } },
+            },
+            {
+                type: 'tool-result',
+                toolCallId: item.id,
+                toolName: 'WebSearch',
+                result: {
+                    action: item.action ?? null,
+                    sources: item.sources ?? (isRecord(item.action) ? item.action.sources : undefined) ?? [],
+                },
+            },
+        ];
+    },
+};

package/node_modules/@maka/runtime/dist/history-compaction.js

@@ -150,6 +150,13 @@ export async function planHistoryCompaction(input) {
     if (phase !== 'standalone' && headAnchorIndex < 0) {
         return { decision: 'fail_open', reason: 'no_safe_completed_span' };
     }
+    // After a retreat the summarizer has already been called and refused, so a
+    // smaller window with nothing safe to fold is that failure, not a pool that
+    // never reached the summarizer (#5790 review).
+    let retreated = false;
+    const noSafeSpan = () => retreated
+        ? { decision: 'fail_open', reason: 'summarizer_failed', diagnosticReason: 'input_too_large' }
+        : { decision: 'fail_open', reason: 'no_safe_completed_span' };
     let maxCoveredCount = input.orderedEvents.length;
     while (maxCoveredCount > 0) {
         const boundary = selectSafeCompactionPrefix(input.orderedEvents, {
@@ -169,9 +176,8 @@ export async function planHistoryCompaction(input) {
             : phase === 'mid_turn'
                 ? boundary.ok && boundary.coveredCount > headAnchorIndex && boundary.coveredCount >= 2
                 : boundary.ok && boundary.coveredCount > 0 && boundary.coveredCount <= headAnchorIndex;
-        if (!boundary.ok || !hasSafeCoverage) {
-            return { decision: 'fail_open', reason: 'no_safe_completed_span' };
-        }
+        if (!boundary.ok || !hasSafeCoverage)
+            return noSafeSpan();
         const coveredRuntimeEvents = input.orderedEvents.slice(0, boundary.coveredCount);
         const tailRuntimeEvents = input.orderedEvents.slice(boundary.coveredCount);
         // Roll forward from a previous checkpoint when it is an exact prefix of the
@@ -239,6 +245,7 @@ export async function planHistoryCompaction(input) {
                         };
                     }
                     maxCoveredCount = proven;
+                    retreated = true;
                     continue;
                 }
                 return {
@@ -295,7 +302,7 @@ export async function planHistoryCompaction(input) {
             estimatedTokensAfter,
         };
     }
-    return { decision: 'fail_open', reason: 'no_safe_completed_span' };
+    return noSafeSpan();
 }
 /** Replay the latest durable checkpoint when it exactly covers the ledger prefix. */
 export function applyRuntimeEventHistoryCompact(events, policy, charsPerToken = 4) {

package/node_modules/@maka/runtime/dist/model-adapter.js

@@ -50,11 +50,9 @@ export class ModelAdapter {
         return {
             toolCalls: true,
             toolResults: true,
-            // Verified against @ai-sdk/open-responses@2.0.34: replay preserves
-            // item order and IDs, but a provider-executed result embedded in the
-            // assistant message (Maka's provider-tool chronology) is still dropped,
-            // leaving a dangling function_call on the wire. Fail closed until the
-            // upstream extension seam (vercel/ai#18899) can round-trip the pair.
+            // General Open Responses provider tool replay remains unsupported.
+            // AiSdkMessageProjection admits only DeepSeek calls with a paired,
+            // original web_search_call item through its narrower per-item check.
             providerExecutedTools: this.runtime.reasoningReplay.kind !== 'responses' ||
                 this.runtime.reasoningReplay.contract.adapter !== 'open-responses',
             signedThinking: this.runtime.reasoningReplay.kind === 'anthropic-signed',
@@ -78,6 +76,12 @@ export class ModelAdapter {
                             : 'none',
         };
     }
+    supportsDeepSeekWebSearchReplay() {
+        return (this.input.connection.providerType === 'deepseek' &&
+            this.runtime.wire === 'openai-responses' &&
+            this.runtime.reasoningReplay.kind === 'responses' &&
+            this.runtime.reasoningReplay.contract.adapter === 'open-responses');
+    }
     resolveModel() {
         if (providerAuthRequiresSecret(this.input.connection.providerType) && !this.input.apiKey) {
             throw new Error(`No API key stored for connection "${this.input.connection.slug}"`);

package/node_modules/@maka/runtime/dist/model-factory.js

@@ -31,6 +31,7 @@ import { modelOverride, resolveThinkingLevel, THINKING_LEVELS, supportsCustomFas
 import { createOpenAiChatReasoningTransport, createOpenAiChatReasoningTransportState, } from './openai-chat-reasoning-transport.js';
 import { openResponsesUrl } from './provider-urls.js';
 import { createOpenResponsesCompatibilityFinalizer } from './open-responses-compatibility.js';
+import { deepSeekWebSearchCodec } from './deepseek-web-search-codec.js';
 import { resolveModelRuntime } from './model-runtime.js';
 import { openAiCodexHeaders } from './subscription-auth.js';
 import { createRequestCustomizationFetch } from './request-customization-fetch.js';
@@ -69,6 +70,9 @@ export function getAIModel(input) {
             apiKey,
             url: openResponsesUrl(baseURL),
             fetch: responsesFetch,
+            ...(connection.providerType === 'deepseek'
+                ? { experimental_extensions: [deepSeekWebSearchCodec] }
+                : {}),
         })(modelId);
     };
     switch (adapter.kind) {

package/node_modules/@maka/runtime/dist/plugin-agent-service.js

@@ -19,26 +19,20 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { Service } from './plugin-kernel.js';
 import { pluginInvocationSignal } from './plugin-invocation-signal.js';
+import { PluginRuntimeBinding } from './plugin-internals.js';
 /** Agent registry and invocation carrier exposed to trusted Host plugins. */
 export class PluginAgentService extends Service {
     invocations = new AsyncLocalStorage();
-    agentRuntime;
+    runtimeBinding;
     constructor(ctx) {
         super(ctx, 'agents');
+        this.runtimeBinding = new PluginRuntimeBinding('agents', 'Agent');
         ctx.accessor('agent', {
             get: () => this.current(),
         });
     }
     bindRuntime(runtime) {
-        if (this.ctx.maka)
-            throw new Error('Only the Host may bind the Agent Runtime');
-        if (this.agentRuntime)
-            throw new Error('Plugin Agent Runtime is already bound');
-        this.agentRuntime = runtime;
-        return this.ctx.effect(() => () => {
-            if (this.agentRuntime === runtime)
-                this.agentRuntime = undefined;
-        }, 'agents.bindRuntime()');
+        return this.runtimeBinding.bind(this.ctx, runtime);
     }
     currentInvocation() {
         return this.invocations.getStore();
@@ -98,9 +92,7 @@ export class PluginAgentService extends Service {
         return Object.freeze((await this.runtime().roots(invocation)).map((descriptor) => this.handle(descriptor, invocation)));
     }
     runtime() {
-        if (!this.agentRuntime)
-            throw new Error('Plugin Agent Runtime is unavailable');
-        return this.agentRuntime;
+        return this.runtimeBinding.get();
     }
     handle(descriptor, invocation = this.requireInvocation()) {
         const service = this;

package/node_modules/@maka/runtime/dist/plugin-attachment-service.js

@@ -17,24 +17,18 @@
  * under the License.
  */
 import { Service } from './plugin-kernel.js';
+import { PluginRuntimeBinding } from './plugin-internals.js';
 /** Session-owned rich result publication and retrieval. */
 export class PluginAttachmentService extends Service {
     agents;
-    attachmentRuntime;
+    runtimeBinding;
     constructor(ctx, agents) {
         super(ctx, 'attachments');
         this.agents = agents;
+        this.runtimeBinding = new PluginRuntimeBinding('attachments', 'Attachment');
     }
     bindRuntime(runtime) {
-        if (this.ctx.maka)
-            throw new Error('Only the Host may bind the Attachment Runtime');
-        if (this.attachmentRuntime)
-            throw new Error('Plugin Attachment Runtime is already bound');
-        this.attachmentRuntime = runtime;
-        return this.ctx.effect(() => () => {
-            if (this.attachmentRuntime === runtime)
-                this.attachmentRuntime = undefined;
-        }, 'attachments.bindRuntime()');
+        return this.runtimeBinding.bind(this.ctx, runtime);
     }
     create(input) {
         return this.runtime().create(input, this.agents.requireInvocation());
@@ -46,8 +40,6 @@ export class PluginAttachmentService extends Service {
         return this.runtime().list(this.agents.requireInvocation());
     }
     runtime() {
-        if (!this.attachmentRuntime)
-            throw new Error('Plugin Attachment Runtime is unavailable');
-        return this.attachmentRuntime;
+        return this.runtimeBinding.get();
     }
 }

package/node_modules/@maka/runtime/dist/plugin-composition-loader.js

@@ -17,10 +17,9 @@
  * under the License.
  */
 /// <reference lib="es2023.collection" />
-import { Context } from './plugin-kernel.js';
+import { Context, FiberState } from './plugin-kernel.js';
+import { freezeCompositionEntry, walkCompositionEntry } from './plugin-internals.js';
 import { fiberStateName, MakaPluginRuntimeError, MakaPluginTransactionBuffer, validateCompositionEntry, validatePluginPackage, validatePluginRootId, } from './plugin-runtime.js';
-const FIBER_PENDING = 0;
-const FIBER_FAILED = 3;
 export class MakaCompositionLoader {
     root;
     #packages = new Map();
@@ -161,7 +160,7 @@ export class MakaCompositionLoader {
             }
             validateCompositionEntry(entry);
             const descendantIds = new Set();
-            for (const item of walk(entry)) {
+            for (const item of walkCompositionEntry(entry)) {
                 if (descendantIds.has(item.id)) {
                     throw new MakaPluginRuntimeError('entry_exists', `Replacement subtree repeats entry ${item.id}`);
                 }
@@ -171,7 +170,7 @@ export class MakaCompositionLoader {
                     throw new MakaPluginRuntimeError('entry_exists', `Composition entry already exists: ${item.id}`);
                 }
             }
-            const inspection = await this.#replace(current, freezeEntry(entry));
+            const inspection = await this.#replace(current, freezeCompositionEntry(entry));
             this.#compositionGeneration += 1;
             return inspection;
         });
@@ -249,7 +248,7 @@ export class MakaCompositionLoader {
                 ...Object.entries(state.roots.sessions).map(([id, entries]) => [`session:${id}`, entries]),
             ]);
             const recoverEntry = async (spec, rootId, parent, parentContext, ancestorDisabled) => {
-                for (const item of walk(spec)) {
+                for (const item of walkCompositionEntry(spec)) {
                     if (stagedIds.has(item.id)) {
                         failures.push(Object.freeze({
                             entryId: spec.id,
@@ -258,7 +257,7 @@ export class MakaCompositionLoader {
                         return undefined;
                     }
                 }
-                const shallow = freezeEntry({ ...spec, children: [] });
+                const shallow = freezeCompositionEntry({ ...spec, children: [] });
                 let live;
                 try {
                     validateCompositionEntry(shallow);
@@ -278,7 +277,10 @@ export class MakaCompositionLoader {
                     if (recovered)
                         live.children.push(recovered);
                 }
-                live.spec = freezeEntry({ ...live.spec, children: live.children.map(serialize) });
+                live.spec = freezeCompositionEntry({
+                    ...live.spec,
+                    children: live.children.map(serialize),
+                });
                 return live;
             };
             try {
@@ -331,7 +333,7 @@ export class MakaCompositionLoader {
                 stagedRoots.set(rootId, root);
                 for (const spec of entries) {
                     validateCompositionEntry(spec);
-                    for (const item of walk(spec)) {
+                    for (const item of walkCompositionEntry(spec)) {
                         if (stagedIds.has(item.id))
                             throw new MakaPluginRuntimeError('entry_exists', `Composition entry already exists: ${item.id}`);
                         stagedIds.add(item.id);
@@ -453,7 +455,13 @@ export class MakaCompositionLoader {
         }
         for (const [service, config] of Object.entries(spec.intercept ?? {}))
             context = context.intercept(service, config);
-        const live = { spec: freezeEntry(spec), rootId, parent, context, children: [] };
+        const live = {
+            spec: freezeCompositionEntry(spec),
+            rootId,
+            parent,
+            context,
+            children: [],
+        };
         const disabled = ancestorDisabled || spec.disabled === true;
         if (!disabled && spec.packageId) {
             const pkg = this.#packages.get(spec.packageId);
@@ -471,16 +479,16 @@ export class MakaCompositionLoader {
             });
             context = context.extend({ maka: metadata });
             const transaction = this.#transaction?.(context) ?? new MakaPluginTransactionBuffer(context);
-            if (transaction)
-                context = context.extend({ makaTransaction: transaction });
+            context = context.extend({ makaTransaction: transaction });
             live.context = context;
             live.generation = generation;
             const plugin = entryPlugin(selectedPlugin, spec.inject);
             live.fiber = context.plugin(plugin, spec.config);
             try {
                 await live.fiber.await();
-                if (live.fiber.state === FIBER_FAILED)
+                if (live.fiber.state === FiberState.FAILED) {
                     throw new Error(`Plugin Fiber failed: ${spec.id}`);
+                }
             }
             catch (error) {
                 live.diagnostic = diagnostic(error);
@@ -492,7 +500,7 @@ export class MakaCompositionLoader {
                     cleanupErrors.push(cleanupError);
                 }
                 try {
-                    await transaction?.rollback();
+                    await transaction.rollback();
                 }
                 catch (cleanupError) {
                     cleanupErrors.push(cleanupError);
@@ -592,7 +600,7 @@ export class MakaCompositionLoader {
     }
     async #update(entryId, patch) {
         const current = this.#requireEntry(entryId);
-        const next = freezeEntry({
+        const next = freezeCompositionEntry({
             ...current.spec,
             ...patch,
             id: current.spec.id,
@@ -637,7 +645,7 @@ export class MakaCompositionLoader {
     }
     #assertUniqueSubtree(entry) {
         const local = new Set();
-        for (const item of walk(entry)) {
+        for (const item of walkCompositionEntry(entry)) {
             if (local.has(item.id) || this.#entries.has(item.id))
                 throw new MakaPluginRuntimeError('entry_exists', `Composition entry already exists: ${item.id}`);
             local.add(item.id);
@@ -658,7 +666,7 @@ export class MakaCompositionLoader {
         const inject = Array.isArray(sourceInject)
             ? sourceInject
             : Object.keys(sourceInject ?? {});
-        const waitingFor = entry.fiber?.state === FIBER_PENDING
+        const waitingFor = entry.fiber?.state === FiberState.PENDING
             ? inject.filter((name) => entry.context.get(name) === undefined)
             : [];
         return Object.freeze({
@@ -732,21 +740,8 @@ function mergeInject(left, right) {
 function freezePackage(pkg) {
     return Object.freeze({ ...pkg, contributions: Object.freeze([...(pkg.contributions ?? [])]) });
 }
-function freezeEntry(entry) {
-    return Object.freeze({
-        ...entry,
-        ...(entry.inject && !Array.isArray(entry.inject)
-            ? { inject: Object.freeze({ ...entry.inject }) }
-            : entry.inject
-                ? { inject: Object.freeze([...entry.inject]) }
-                : {}),
-        ...(entry.isolate ? { isolate: Object.freeze({ ...entry.isolate }) } : {}),
-        ...(entry.intercept ? { intercept: Object.freeze({ ...entry.intercept }) } : {}),
-        children: Object.freeze((entry.children ?? []).map(freezeEntry)),
-    });
-}
 function serialize(entry) {
-    return freezeEntry({ ...entry.spec, children: entry.children.map(serialize) });
+    return freezeCompositionEntry({ ...entry.spec, children: entry.children.map(serialize) });
 }
 function shallowCompositionEqual(left, right) {
     if (Object.is(left, right))
@@ -759,11 +754,6 @@ function shallowCompositionEqual(left, right) {
         leftEntries.every(([key, value]) => Object.hasOwn(right, key) &&
             Object.is(value, right[key])));
 }
-function* walk(entry) {
-    yield entry;
-    for (const child of entry.children ?? [])
-        yield* walk(child);
-}
 function* walkLive(entry) {
     yield entry;
     for (const child of entry.children)

package/node_modules/@maka/runtime/dist/plugin-data-services.js

@@ -18,28 +18,20 @@
  */
 import { Service } from './plugin-kernel.js';
 import { pluginIdentity, registerPluginContribution } from './plugin-runtime.js';
+import { PluginRuntimeBinding } from './plugin-internals.js';
 class PluginNamespacedDataService extends Service {
     domain;
-    dataRuntime;
+    runtimeBinding;
     constructor(ctx, name, domain) {
         super(ctx, name);
         this.domain = domain;
+        this.runtimeBinding = new PluginRuntimeBinding(name, domain, `Plugin ${domain}`);
     }
     bindRuntime(runtime) {
-        if (this.ctx.maka)
-            throw new Error(`Only the Host may bind the Plugin ${this.domain} Runtime`);
-        if (this.dataRuntime)
-            throw new Error(`Plugin ${this.domain} Runtime is already bound`);
-        this.dataRuntime = runtime;
-        return this.ctx.effect(() => () => {
-            if (this.dataRuntime === runtime)
-                this.dataRuntime = undefined;
-        }, `${this.domain}.bindRuntime()`);
+        return this.runtimeBinding.bind(this.ctx, runtime);
     }
     runtime() {
-        if (!this.dataRuntime)
-            throw new Error(`Plugin ${this.domain} Runtime is unavailable`);
-        return this.dataRuntime;
+        return this.runtimeBinding.get();
     }
     namespace() {
         const { extensionId, scopeId } = pluginIdentity(this.ctx);
@@ -158,21 +150,14 @@ export class PluginStorageService extends PluginNamespacedDataService {
 const authorizationCommit = Symbol('authorizationCommit');
 /** Declared Secret Slots. Values stay in Host custody and are never enumerable. */
 export class PluginCredentialService extends Service {
-    dataRuntime;
+    runtimeBinding;
     slots = new Map();
     constructor(ctx) {
         super(ctx, 'credentials');
+        this.runtimeBinding = new PluginRuntimeBinding('credentials', 'Credential');
     }
     bindRuntime(runtime) {
-        if (this.ctx.maka)
-            throw new Error('Only the Host may bind the Credential Runtime');
-        if (this.dataRuntime)
-            throw new Error('Plugin Credential Runtime is already bound');
-        this.dataRuntime = runtime;
-        return this.ctx.effect(() => () => {
-            if (this.dataRuntime === runtime)
-                this.dataRuntime = undefined;
-        }, 'credentials.bindRuntime()');
+        return this.runtimeBinding.bind(this.ctx, runtime);
     }
     declare(slot) {
         validateSlot(slot);
@@ -215,9 +200,7 @@ export class PluginCredentialService extends Service {
         return slot;
     }
     runtime() {
-        if (!this.dataRuntime)
-            throw new Error('Plugin Credential Runtime is unavailable');
-        return this.dataRuntime;
+        return this.runtimeBinding.get();
     }
 }
 /** Effect-owned authorization flows with one cancellable attempt per Secret Slot. */