@qlzt/dsh-subagent 0.0.0-stage → 0.2.1-alpha.2

package/lib/types/lifecycle.js

@@ -0,0 +1,115 @@
+/**
+ * Lifecycle-edge publication for managed subagent activations.
+ *
+ * Public event payloads live in `./types.ts`; the package-private observer
+ * retains only the identity shared by each start/end pair.
+ *
+ * @module @qlzt/dsh-subagent/lifecycle
+ */
+import { randomUUID } from 'node:crypto';
+import { foldConsumedWork } from '@qlzt/dsh-agent';
+import { SubagentRunId } from "./types.js";
+/**
+ * Build the contained lifecycle emitter this seam publishes every edge through.
+ * Every listener is independently contained: a synchronous throw or a rejected
+ * returned promise is logged without starving peer listeners, changing the run,
+ * or — for provider removal, which fires from a disposer — breaking teardown.
+ * @param ctx - the service's own context, owning dispatch and the logger.
+ * @param carrier - resolve the scoped dispatch carrier for one delegating parent.
+ * @returns the emitter both observers and the provider registry publish through.
+ */
+export function createLifecycleEmitter(ctx, carrier) {
+    return (name, info, parent) => {
+        const dispatchArgs = parent === undefined
+            ? [name, info]
+            : [carrier(parent), name, info];
+        for (const callback of ctx.events.dispatch('emit', dispatchArgs)) {
+            try {
+                const returned = callback(info);
+                void Promise.resolve(returned).catch((error) => {
+                    ctx.logger.warn(`subagent: ${name} listener rejected: ${renderThrown(error)}`);
+                });
+            }
+            catch (error) {
+                ctx.logger.warn(`subagent: ${name} listener threw: ${renderThrown(error)}`);
+            }
+        }
+    };
+}
+/**
+ * Build the observer for one local or external activation's residency epoch. Creation failure before residency emits no lifecycle edge.
+ * @param emit - the contained lifecycle emitter.
+ * @param provider - the provider name recorded in the durable descriptor.
+ * @param childId - the durable child session id.
+ * @param parent - the exact live direct parent keying scoped dispatch.
+ * @returns the observer whose edges this epoch publishes.
+ */
+export function createActivationObserver(emit, provider, childId, parent) {
+    const identity = { runId: SubagentRunId(randomUUID()), provider, id: childId, local: false };
+    return {
+        start: (child) => {
+            identity.local = child !== undefined;
+            emit('subagent/start', identity, parent);
+        },
+        settle: ({ stopReason, output }) => {
+            emit('subagent/end', {
+                ...identity,
+                stopReason,
+                ...output.length === 0 ? {} : { lastAssistantMessage: output },
+            }, parent);
+        },
+    };
+}
+/**
+ * Why this child's epoch ended, for the terminal lifecycle edge and the
+ * manager's own parent delivery. The child's own log is authoritative:
+ * teardown succeeding says nothing about whether the model errored, hit its
+ * token ceiling, or was cancelled, so deriving the reason from disposal would
+ * report failed work as completed.
+ *
+ * {@link foldConsumedWork} supplies both halves the raw turn sequence cannot:
+ * which turn accounts for the work this epoch consumed, and whether accepted
+ * work was cancelled after it without any turn opening over it. A recorded
+ * failure still wins over a cancellation — stopping a child that had already
+ * failed does not turn its failure into a cancellation.
+ * @param events - this epoch's own event suffix.
+ * @returns its terminal stop reason; `completed` only for an epoch that both
+ *   closed cleanly and had nothing left to run.
+ */
+export function epochStopReason(events) {
+    const { end, droppedUnrun } = foldConsumedWork(events);
+    switch (end?.data.reason.kind) {
+        case 'max-tokens':
+            return 'max-tokens';
+        case 'aborted':
+        case 'interrupted':
+            return 'aborted';
+        case 'error':
+            return 'error';
+        // A pre-step rejection — a hook deny, a policy plugin — discarded input
+        // this epoch had claimed: the work was declined, not done.
+        case 'blocked':
+            return 'refusal';
+        // A clean ending and no accounting turn at all share one rule: the epoch
+        // finished what it was given unless a cancelled queue says otherwise.
+        case undefined:
+        case 'completed':
+            return droppedUnrun ? 'aborted' : 'completed';
+        /* v8 ignore next 4 -- `forked` appears only in constructor seed history, while
+         * this function reads an epoch-owned suffix. `TurnEndReason` is merge-extensible,
+         * so a backend-added variant cannot be listed; treating an unnameable reason as
+         * success would report failed work as completed. */
+        default:
+            return 'error';
+    }
+}
+/** Render any listener-thrown value without letting coercion escape containment. */
+function renderThrown(value) {
+    try {
+        return value instanceof Error ? `${value.name}: ${value.message}` : String(value);
+    }
+    catch {
+        return '<unrenderable thrown value>';
+    }
+}
+//# sourceMappingURL=lifecycle.js.map

package/lib/types/list-children.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Direct-child and recursive descendant discovery from parent-owned catalogs.
+ * Each catalog read releases its Session observation before the next branch.
+ * @module @qlzt/dsh-subagent
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@qlzt/dsh-session';
+import type { SubagentListEntry } from './control-types.ts';
+import type { SubagentCatalogEntry } from './projection-types.ts';
+export type { SubagentListEntry } from './control-types.ts';
+/** One catalog descendant with its direct parent and edge distance from the requested root. */
+export type SubagentDescendantListEntry = SubagentListEntry & {
+    /** Parent whose catalog contains this child. */
+    readonly parentId: SessionId;
+    /** Edge distance from the requested root; direct children are `1`. */
+    readonly depth: number;
+};
+/**
+ * Read one parent's durable catalog through a live-preferred Session observation.
+ * @param ctx - context carrying the Session query service.
+ * @param parentSessionId - parent whose direct children are requested.
+ * @param signal - cancellation forwarded to the Session observation.
+ * @returns direct-child rows in parent catalog event order.
+ * @throws {@link SubagentError} when query or catalog projection is unavailable.
+ */
+export declare function listChildren(ctx: Context, parentSessionId: SessionId, signal?: AbortSignal): Promise<SubagentCatalogEntry[]>;
+/**
+ * Walk reachable parent catalogs in stable pre-order without loading Agents.
+ * @see SubagentRuntime.listDescendants for failure and cancellation semantics.
+ * @param ctx - context carrying the Session store and query service.
+ * @param rootSessionId - parent whose catalog starts the traversal.
+ * @param signal - cancellation checked around each catalog read.
+ * @returns children and branch diagnostics with catalog parent and depth.
+ */
+export declare function listDescendants(ctx: Context, rootSessionId: SessionId, signal?: AbortSignal): Promise<SubagentDescendantListEntry[]>;
+//# sourceMappingURL=list-children.d.ts.map

package/lib/types/list-children.js

@@ -0,0 +1,166 @@
+/**
+ * Direct-child and recursive descendant discovery from parent-owned catalogs.
+ * Each catalog read releases its Session observation before the next branch.
+ * @module @qlzt/dsh-subagent
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { SubagentError } from "./error.js";
+/**
+ * Read one parent's durable catalog through a live-preferred Session observation.
+ * @param ctx - context carrying the Session query service.
+ * @param parentSessionId - parent whose direct children are requested.
+ * @param signal - cancellation forwarded to the Session observation.
+ * @returns direct-child rows in parent catalog event order.
+ * @throws {@link SubagentError} when query or catalog projection is unavailable.
+ */
+export async function listChildren(ctx, parentSessionId, signal) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const query = ctx.get('sessionQuery');
+        if (query === undefined) {
+            throw new SubagentError('listing subagents requires the sessionQuery service (load @qlzt/dsh-session-query)', 'SUBAGENT_CONTROL_QUERY_UNAVAILABLE');
+        }
+        const parent = __addDisposableResource(env_1, await query.observeSession(parentSessionId, {
+            ...signal === undefined ? {} : { signal },
+        }), false);
+        const entries = parent.projections?.values.subagentCatalog;
+        if (entries === undefined) {
+            throw new SubagentError('listing subagents requires the registered subagentCatalog projection', 'SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE');
+        }
+        return entries;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
+/**
+ * Walk reachable parent catalogs in stable pre-order without loading Agents.
+ * @see SubagentRuntime.listDescendants for failure and cancellation semantics.
+ * @param ctx - context carrying the Session store and query service.
+ * @param rootSessionId - parent whose catalog starts the traversal.
+ * @param signal - cancellation checked around each catalog read.
+ * @returns children and branch diagnostics with catalog parent and depth.
+ */
+export async function listDescendants(ctx, rootSessionId, signal) {
+    const sessions = ctx.get('sessions');
+    if (sessions === undefined) {
+        throw new SubagentError('listing subagents requires the session store (load @qlzt/dsh-session)', 'SUBAGENT_CONTROL_SESSION_STORE_UNAVAILABLE');
+    }
+    const readChildren = async (id) => {
+        assertListingNotCancelled(signal);
+        let children;
+        try {
+            children = await listChildren(ctx, id, signal);
+        }
+        catch (error) {
+            assertListingNotCancelled(signal);
+            throw error;
+        }
+        assertListingNotCancelled(signal);
+        return children;
+    };
+    const stack = (await readChildren(rootSessionId))
+        .map(entry => ({ entry, parentId: rootSessionId, depth: 1 }))
+        .reverse();
+    const visited = new Set([rootSessionId]);
+    const result = [];
+    for (let position = stack.pop(); position !== undefined; position = stack.pop()) {
+        const { entry, parentId, depth } = position;
+        if (visited.has(entry.id))
+            continue;
+        visited.add(entry.id);
+        let children;
+        try {
+            children = entry.mode === 'external' ? [] : await readChildren(entry.id);
+        }
+        catch (error) {
+            if (error instanceof SubagentError)
+                throw error;
+            const code = error instanceof Error && 'code' in error ? error.code : undefined;
+            result.push({
+                kind: 'diagnostic', id: entry.id, parentId, depth,
+                reason: code === 'SESSION_QUERY_CORRUPT_SESSION' || code === 'SESSION_QUERY_SOURCE_CONFLICT'
+                    ? 'corrupt' : 'unavailable',
+            });
+            continue;
+        }
+        if (entry.mode === 'unknown') {
+            result.push({ kind: 'diagnostic', id: entry.id, parentId, depth, reason: 'unsupported' });
+        }
+        else {
+            const { createdAt: _createdAt, ...identity } = entry;
+            result.push({
+                ...identity, kind: 'child', parentId, depth,
+                activity: sessions.get(entry.id) === undefined ? 'inactive' : 'running',
+                hasChildren: children.length > 0,
+            });
+        }
+        // Catalog event order defines siblings; the stack visits the first one next.
+        for (const child of [...children].reverse()) {
+            stack.push({ entry: child, parentId: entry.id, depth: depth + 1 });
+        }
+    }
+    return result;
+}
+/** Stop the complete traversal when its caller cancels. */
+function assertListingNotCancelled(signal) {
+    if (signal?.aborted) {
+        throw new SubagentError('subagent listing was cancelled', 'CANCELLED');
+    }
+}
+//# sourceMappingURL=list-children.js.map

package/lib/types/manager.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Owns subagent startup, message admission, cold resume, and execution lifetimes.
+ * One child lock orders input acceptance and closure; one activation map owns
+ * capacity, parent relationships, and resource release across all providers.
+ *
+ * @module @qlzt/dsh-subagent/manager
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@qlzt/dsh-agent';
+import type { ContentBlock, MessageId, MessageSource } from '@qlzt/dsh-llm';
+import type { SessionId } from '@qlzt/dsh-session';
+import type { ActivationObserver } from './lifecycle.ts';
+import type { ContinuableCreateRequest, ContinuableCreateSpec, SubagentInterruptAuthority, SubagentActivationSpec, SubagentActivation, SubagentRun, SubagentSendMessageOptions, ResolvedSubagentStartRequest } from './types.ts';
+/** Package-private hooks supplied by the owning service. */
+interface SubagentHost {
+    startExternal(name: string, request: ResolvedSubagentStartRequest): Promise<SubagentRun>;
+    /** Resolve one provider's detached continuable-creation contribution. */
+    prepareContinuable(name: string, request: ContinuableCreateRequest): Promise<ContinuableCreateSpec>;
+    /** Build the lifecycle observer for one Activation residency epoch. */
+    observeActivation(provider: string, childId: SessionId, parent: Agent): ActivationObserver;
+}
+/** Own subagent requests and the resources of every live activation. */
+export declare class SubagentManager {
+    private readonly ctx;
+    private readonly host;
+    private readonly maxActiveSubagents;
+    /** Child session id → its live Activation. Process-local, never durable. */
+    private readonly resident;
+    /** Root identities retain their pool across child settlement without retaining dead roots. */
+    private readonly rootPools;
+    /** Materializations admitted before drain, tracked through publication or rollback. */
+    private readonly materializations;
+    /** Per-child serializer shared by delivery, release, and disposal. */
+    private readonly locks;
+    /** Structural Cordis owner of every Activation handle. */
+    private readonly ownerCtx;
+    /**
+     * Exact roots whose host teardown has begun, with the live lineage members
+     * observed under each root. Entries remain until that exact root leaves the
+     * Agent registry, closing admission throughout its host's teardown without
+     * poisoning a later same-id replacement.
+     */
+    private readonly closingScopes;
+    private draining;
+    /**
+     * Build one manager inside the service's Agent-injected context.
+     * @param ctx - context providing Agents, Sessions, and teardown ownership.
+     * @param host - provider dispatch and lifecycle observation owned by the service.
+     * @param maxActiveSubagents - the current configured child capacity.
+     */
+    constructor(ctx: Context, host: SubagentHost, maxActiveSubagents: () => number);
+    /**
+     * Interrupt one live continuable child's current turn under the supplied authority.
+     * @param targetSessionId - the durable child session id to interrupt.
+     * @param authority - the human parent address or exact live ancestor Agent.
+     */
+    interrupt(targetSessionId: SessionId, authority: SubagentInterruptAuthority): void;
+    /**
+     * Close admission, await every already-admitted materialization through
+     * publication or rollback, then dispose the stable live Activation graph
+     * child-first.
+     */
+    drain(): Promise<void>;
+    /**
+     * Join progressing child work, leaving idle parked inboxes resident.
+     * @param parent - exact live parent whose descendants are observed.
+     * @returns whether work was joined and the host must recheck parent completion.
+     */
+    waitForChildren(parent: Agent): Promise<boolean>;
+    /**
+     * Stop the managed descendants of exact live host-owned parents.
+     * @param parents - exact live roots whose managed descendants must stop.
+     */
+    drainDescendants(parents: readonly Agent[]): Promise<void>;
+    /**
+     * Release selected resident direct children of one exact live parent.
+     * @param parent - exact live direct parent authorizing the selected release.
+     * @param childIds - durable direct-child ids to release when resident.
+     */
+    drainChildren(parent: Agent, childIds: readonly SessionId[]): Promise<void>;
+    /**
+     * Start one continuable background child and resolve at initial inbox acceptance.
+     * Every earlier failure disposes any created handle and rolls back Activation
+     * and parent ownership without returning either id.
+     * @param spec - provider, delegation request, and caller cancellation.
+     * @returns the durable child id and accepted initial prompt message id.
+     */
+    startLocal(spec: SubagentActivationSpec): Promise<SubagentActivation & {
+        messageId: MessageId;
+    }>;
+    /**
+     * Start an external backend under activation ownership.
+     * @param spec - task, provider, cancellation, and delivery policy.
+     * @returns the accepted activation and its result/disposal capabilities.
+     */
+    startExternal(spec: SubagentActivationSpec): Promise<SubagentActivation>;
+    /** Capture the explicit or inherited directory while the parent still owns startup. */
+    private resolveDirectory;
+    /**
+     * Deliver one model-authored message to a direct continuable child or to the
+     * sender's direct parent. A missing direct child cold-resumes through the
+     * ordinary continuation lifecycle.
+     * @param sender - exact live Agent authorizing and originating the message.
+     * @param targetId - durable direct-parent or direct-child session id.
+     * @param content - model-authored content to deliver.
+     * @param options - caller cancellation before acceptance.
+     * @returns the accepted message's inbox id.
+     */
+    sendMessage(sender: Agent, targetId: SessionId, content: ContentBlock[], options: SubagentSendMessageOptions): Promise<MessageId>;
+    /**
+     * Queue one human-authored prompt as a distinct direct-child turn.
+     * @param parent - exact live direct parent authorizing delivery.
+     * @param childId - durable direct-child session id.
+     * @param content - model-visible prompt blocks.
+     * @param source - durable attribution for the human prompt.
+     * @param signal - caller cancellation before inbox acceptance.
+     * @returns the accepted durable message id.
+     */
+    queuePrompt(parent: Agent, childId: SessionId, content: ContentBlock[], source: MessageSource, signal: AbortSignal): Promise<MessageId>;
+    /**
+     * Steer one host-authored prompt to a direct continuable child.
+     * @param parent - exact live direct parent authorizing delivery.
+     * @param childId - durable direct-child session id.
+     * @param content - model-visible prompt blocks.
+     * @param source - durable attribution for the host prompt.
+     * @param signal - caller cancellation before inbox acceptance.
+     * @returns the accepted durable message id.
+     */
+    steerPrompt(parent: Agent, childId: SessionId, content: ContentBlock[], source: MessageSource, signal: AbortSignal): Promise<MessageId>;
+    /** Admit local input synchronously before any teardown can begin. */
+    private deliver;
+    /**
+     * Reject one child identity already owned by a live Agent or Session.
+     * @param childId - proposed durable child session id.
+     */
+    private assertChildIdAvailable;
+    /**
+     * Pre-register `childId` in a continuation-managed parent's owned set so the
+     * parent cannot settle while a caller is still establishing or resuming that
+     * child. Returns a releaser for the failure path; it removes only a hold
+     * this call added, and leaves ownership in place once a live Activation for
+     * the child exists.
+     * @param parent - the live direct parent the operation is admitted under.
+     * @param childId - the durable child the operation addresses.
+     * @returns the failure-path releaser; a no-op when nothing was added.
+     */
+    private holdOwnership;
+    /**
+     * Apply activation admission to a resident parent before delivering input.
+     * @param parent - exact live Agent receiving the message.
+     * @param message - durable user message to deliver.
+     * @param delivery - receiving inbox destination.
+     */
+    private sendWaking;
+    /**
+     * Reject new admission once the manager or this exact parent tree began draining.
+     * @param agent - exact live Agent whose lineage determines admission.
+     */
+    private assertAdmitting;
+    /**
+     * Authorize one operation against the durable direct-parent lineage.
+     * @param parent - exact live Agent claiming direct-parent authority.
+     * @param childId - durable child session id addressed by the operation.
+     * @param parentSession - durable direct-parent id recorded by the child.
+     */
+    private authorizeLineage;
+    /** Reject parent authority after the live registry entry changes. */
+    private assertLiveParent;
+    /**
+     * Create or resume one child Agent and publish its Activation.
+     * @param inputs - reconstruction and admission inputs for the residency epoch.
+     * @returns the published process-local Activation.
+     */
+    private materialize;
+    /**
+     * Stop and release one Activation through its memoized close transaction.
+     * @param activation - exact residency epoch to close.
+     * @returns the shared close transaction.
+     */
+    private dispose;
+    /** Close admission synchronously and share one release, including startup rollback. */
+    private close;
+    /** Dispose independent roots and report every branch failure after all settle. */
+    private disposeRoots;
+    /** Return the retained member set for one exact scoped-teardown root. */
+    private closingMembers;
+    /** Return the exact currently resolvable ancestry from `agent` upward. */
+    private liveLineage;
+    /** Return the teardown that closed continuable admission for this agent's lineage. */
+    private closingTeardownFor;
+    /** Resolve a root's pool once; descendants inherit their resident parent's pool directly. */
+    private rootPool;
+    /** Perform one tracked materialization through publication or rollback. */
+    private materializeTracked;
+    /**
+     * Begin settlement observation after initial acceptance is recorded.
+     * @param activation - accepted activation to observe.
+     */
+    private announce;
+    /** Release an Activation whose start edge was not published. */
+    private rollbackUnpublished;
+    /** Register the child in a continuation-managed parent's owned set. */
+    private acquireOwnership;
+    /** Remove one child from its live owner's set and let that owner re-check settlement. */
+    private releaseOwnership;
+    /** Let a settlement watcher re-check residency after relevant state changes. */
+    private wake;
+    /** Follow one Activation to natural settlement. */
+    private watchLocalSettlement;
+    /** Report disposal failure once after the natural settlement observer finishes. */
+    private reportTeardownFailure;
+    /** Check pending input and owned children before closing admission. */
+    private settlementState;
+    /** Propagate stop synchronously and await descendant startup rollback before release. */
+    private finishDisposal;
+    /** Deliver the captured execution result to the durable direct parent after cleanup. */
+    private notifySettlement;
+    /** Request a best-effort final session flush before closing natural-settlement admission. */
+    private flushFinalState;
+    /** Return capabilities bound to an exact activation instead of a future same-id instance. */
+    private receipt;
+    /** Route one parent-originated delivery through residency and cold resume. */
+    private deliverToChild;
+    /** The delivery loop behind {@link deliverToChild}, run under the parent hold. */
+    private deliverFollowup;
+    /** Deliver one resident continuable child's message to its live direct parent. */
+    private sendToParent;
+    /** Send one Agent message while translating only the target's own rejection. */
+    private sendAgentMessage;
+    /**
+     * Cold-resume a persisted child and submit the waiting turn. The descriptor
+     * supplies every reconstruction input; no subagent provider is dispatched.
+     */
+    private coldResume;
+    /** Admit a materialized child, commit its creation fact, and release it on failure. */
+    private submitMaterialized;
+    /** Build and submit one message across the final synchronous admission cutoff. */
+    private submitAdmitted;
+    /** Refuse image content for a child whose fixed model accepts text only. */
+    private assertImageCapable;
+    /** Resolve the persistence service continuable children require, or fail loud. */
+    private requirePersistence;
+    /** Resolve the Session query service used for cold child observations. */
+    private requireSessionQuery;
+}
+export default SubagentManager;
+//# sourceMappingURL=manager.d.ts.map