@langchain/langgraph-sdk 1.9.29 → 1.9.31

package/dist/stream/controller.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.cts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;AA6KA;;cAAa,kBAAA,WAA6B,OAAA;;AAkC1C;;;;;;;;;;;;cAAa,gBAAA,4BACgB,MAAA,8EAEO,MAAA;EAAA;WAEzB,SAAA,EAAW,WAAA,CAAY,YAAA,CAAa,SAAA,EAAW,aAAA;EAAA,SAC/C,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,mBAAA,EAAqB,WAAA,CAAY,iBAAA;EAAA,SACjC,oBAAA,EAAsB,WAAA,CAAY,kBAAA;EAAA,SAClC,UAAA,EAAY,WAAA,CAAY,uBAAA,CAAwB,SAAA;EAAA,SAChD,QAAA,EAAU,eAAA;EAgI0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAsyBF;;;;;;;EAAA,IAvrBvC,gBAAA,CAAA,GAAoB,OAAA;EA41BS;;;;;;;;EAnyB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAihCpB;;;;;;;;;;;;;;EAzpBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EArqB5B;;;;;;;;EAy6BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAz6B4B;;;;;;EAm7BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAj7BtB;;;;EAq8Bb,UAAA,CAAA,GAAc,OAAA;EAttBhB;;;;;;;;;;;EAsxBE,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FW;;;EAsGrC,UAAA,CAAA,GAAc,OAAA;EA3FC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJf,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+GG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA0DG,OAAA,CAAA,GAAW,OAAA;;;;;;;;;;;;;;;;EAyBjB,QAAA,CAAA;;;;;;EA4BA,SAAA,CAAA,GAAa,YAAA;;;;;;;;EAWb,eAAA,CACE,QAAA,GAAW,MAAA,EAAQ,YAAA;AAAA"}
+{"version":3,"file":"controller.d.cts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;AA6KA;;cAAa,kBAAA,WAA6B,OAAA;;AAkC1C;;;;;;;;;;;;cAAa,gBAAA,4BACgB,MAAA,8EAEO,MAAA;EAAA;WAEzB,SAAA,EAAW,WAAA,CAAY,YAAA,CAAa,SAAA,EAAW,aAAA;EAAA,SAC/C,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,mBAAA,EAAqB,WAAA,CAAY,iBAAA;EAAA,SACjC,oBAAA,EAAsB,WAAA,CAAY,kBAAA;EAAA,SAClC,UAAA,EAAY,WAAA,CAAY,uBAAA,CAAwB,SAAA;EAAA,SAChD,QAAA,EAAU,eAAA;EAqJ0B;;;;;EAA7C,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAszBF;;;;;;;EAAA,IA5rBvC,gBAAA,CAAA,GAAoB,OAAA;EAi2BS;;;;;;;;EAxyB3B,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EA0hCpB;;;;;;;;;;;;;;EA7pBf,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EA1sB5B;;;;;;;;EA88BlB,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EA98B4B;;;;;;EAw9BzB,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAt9BtB;;;;EA0+Bb,UAAA,CAAA,GAAc,OAAA;EA3tBhB;;;;;;;;;;;EA2xBE,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FW;;;EAsGrC,UAAA,CAAA,GAAc,OAAA;EA3FC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJf,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA4DG,OAAA,CAAA,GAAW,OAAA;;;;;;;;;;;;;;;;EAyBjB,QAAA,CAAA;;;;;;EA4BA,SAAA,CAAA,GAAa,YAAA;;;;;;;;EAWb,eAAA,CACE,QAAA,GAAW,MAAA,EAAQ,YAAA;AAAA"}

package/dist/stream/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;;AA6KA;cAAa,kBAAA,WAA6B,OAAA;;;AAkC1C;;;;;;;;;;;cAAa,gBAAA,4BACgB,MAAA,8EAEO,MAAA;EAAA;WAEzB,SAAA,EAAW,WAAA,CAAY,YAAA,CAAa,SAAA,EAAW,aAAA;EAAA,SAC/C,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,mBAAA,EAAqB,WAAA,CAAY,iBAAA;EAAA,SACjC,oBAAA,EAAsB,WAAA,CAAY,kBAAA;EAAA,SAClC,UAAA,EAAY,WAAA,CAAY,uBAAA,CAAwB,SAAA;EAAA,SAChD,QAAA,EAAU,eAAA;EAAA;;;;;EAgInB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAsyBb;;;;;;;EAAA,IAvrB5B,gBAAA,CAAA,GAAoB,OAAA;EA6xBJ;;;;;;;;EApuBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EAqgC5B;;;;;;;;;;;;;;EA7oBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EArqB3C;;;;;;;;EAy6BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAz6BM;;;;;;EAm7BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAj7BhC;;;;EAq8BH,UAAA,CAAA,GAAc,OAAA;EAr0BR;;;;;;;;;;;EAq4BN,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FA;;;EAsG1B,UAAA,CAAA,GAAc,OAAA;EA3Fd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJA,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+GG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA0DG,OAAA,CAAA,GAAW,OAAA;;;;;;;;;;;;;;;;EAyBjB,QAAA,CAAA;;;;;;EA4BA,SAAA,CAAA,GAAa,YAAA;;;;;;;;EAWb,eAAA,CACE,QAAA,GAAW,MAAA,EAAQ,YAAA;AAAA"}
+{"version":3,"file":"controller.d.ts","names":[],"sources":["../../src/stream/controller.ts"],"mappings":";;;;;;;;;;;;;;;AA6KA;cAAa,kBAAA,WAA6B,OAAA;;;AAkC1C;;;;;;;;;;;cAAa,gBAAA,4BACgB,MAAA,8EAEO,MAAA;EAAA;WAEzB,SAAA,EAAW,WAAA,CAAY,YAAA,CAAa,SAAA,EAAW,aAAA;EAAA,SAC/C,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,aAAA,EAAe,WAAA,CAAY,WAAA;EAAA,SAC3B,mBAAA,EAAqB,WAAA,CAAY,iBAAA;EAAA,SACjC,oBAAA,EAAsB,WAAA,CAAY,kBAAA;EAAA,SAClC,UAAA,EAAY,WAAA,CAAY,uBAAA,CAAwB,SAAA;EAAA,SAChD,QAAA,EAAU,eAAA;EAAA;;;;;EAqJnB,WAAA,CAAY,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAszBb;;;;;;;EAAA,IA5rB5B,gBAAA,CAAA,GAAoB,OAAA;EAkyBJ;;;;;;;;EAzuBd,OAAA,CAAQ,QAAA,mBAA2B,OAAA;EA8gC5B;;;;;;;;;;;;;;EAjpBP,wBAAA,CAAyB,UAAA,WAAqB,OAAA;EA1sB3C;;;;;;;;EA88BH,MAAA,CACJ,KAAA,WACA,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EA98BM;;;;;;EAw9BH,IAAA,CAAK,OAAA,GAAU,iBAAA,GAAoB,OAAA;EAt9BhC;;;;EA0+BH,UAAA,CAAA,GAAc,OAAA;EAr1BR;;;;;;;;;;;EAq5BN,YAAA,CAAa,EAAA,WAAa,OAAA;EA/FA;;;EAsG1B,UAAA,CAAA,GAAc,OAAA;EA3Fd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJA,OAAA,CACJ,QAAA,WACA,OAAA,GAAU,oBAAA,CAAqB,gBAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHG,UAAA,CACJ,aAAA,EAAe,MAAA,mBACf,OAAA,GAAU,uBAAA,CAAwB,gBAAA,IACjC,OAAA;;;;EA4DG,OAAA,CAAA,GAAW,OAAA;;;;;;;;;;;;;;;;EAyBjB,QAAA,CAAA;;;;;;EA4BA,SAAA,CAAA,GAAa,YAAA;;;;;;;;EAWb,eAAA,CACE,QAAA,GAAW,MAAA,EAAQ,YAAA;AAAA"}

package/dist/stream/controller.js

@@ -154,12 +154,25 @@ var StreamController = class {
 	* SSE replay re-adds historically-requested interrupts that have
 	* since been resolved (no `input.responded` event exists in the
 	* protocol, so the SDK has no other way to tell replay from live
-	* for an idle thread). `null` outside the hydrate-window so
-	* genuinely new live interrupts on an active run aren't filtered;
-	* cleared at the start of `submit()` for the same reason.
+	* for an idle thread). After a command is accepted, events newer
+	* than {@link #interruptReplayThroughSeq} bypass the allowlist.
 	*/
 	#hydratedActiveInterruptIds = null;
 	/**
+	* Highest event sequence already applied when the latest run command
+	* was accepted. Interrupts outside the hydrate-time allowlist remain
+	* filtered through this sequence, while newer events are live output
+	* from the newly-started run and must be accepted.
+	*/
+	#interruptReplayThroughSeq;
+	/**
+	* Unknown interrupt events received between local command dispatch and its
+	* response. The response supplies the sequence barrier needed to classify
+	* each event as historical replay or live output from the new run.
+	*/
+	#pendingInterruptEvents = [];
+	#interruptCommandPending = false;
+	/**
 	* Monotonic counter bumped at the start of each `submit()` and used
 	* by {@link hydrate} to skip its post-fetch allowlist write when a
 	* submit started while the state fetch was in flight. Without this
@@ -169,6 +182,14 @@ var StreamController = class {
 	*/
 	#submitGeneration = 0;
 	/**
+	* Monotonic counter bumped at the start of each `#teardownThread`.
+	* The root pump captures the generation when it starts and drops
+	* any event whose generation no longer matches — including queued
+	* events that `SubscriptionHandle.close()` still drains after the
+	* snapshot has already been cleared by `hydrate()`.
+	*/
+	#rootPumpGeneration = 0;
+	/**
 	* Thread ids this controller minted client-side on first `submit()`.
 	* `hydrate()` skips `threads.getState()` for these — we know there
 	* is nothing checkpointed yet. Cleared once dispatch commits the
@@ -293,13 +314,20 @@ var StreamController = class {
 			awaitNextTerminal: (signal) => this.#awaitNextTerminal(signal),
 			awaitResumedRunTerminal: (signal) => this.#awaitResumedRunTerminal(signal),
 			onSubmitStart: () => {
-				this.#hydratedActiveInterruptIds = null;
 				this.#submitGeneration += 1;
+				this.#interruptCommandPending = this.#hydratedActiveInterruptIds != null;
+				this.#pendingInterruptEvents = [];
 			},
 			onRunStart: () => this.#markLocalRunStart(),
-			onRunCreated: (runId) => this.#notifyCreated(runId),
+			onRunCreated: (runId) => {
+				this.#advanceInterruptReplayBarrier();
+				this.#notifyCreated(runId);
+			},
 			onRunCompleted: (reason, runId) => this.#notifyCompleted(reason, runId),
-			onRunEnd: () => this.#markLocalRunEnd(),
+			onRunEnd: () => {
+				this.#interruptCommandPending = false;
+				this.#markLocalRunEnd();
+			},
 			beginOptimistic: (input) => this.#beginOptimistic(input),
 			settleOptimistic: (handle, event) => this.#settleOptimistic(handle, event)
 		});
@@ -391,13 +419,16 @@ var StreamController = class {
 			* Suspense boundary remounted against the new id suspends again.
 			*/
 			this.#resetHydrationPromise();
-			await this.#teardownThread();
 			/**
-			* Reset UI-facing snapshot so stale messages/values/tool-calls
-			* from the previous thread don't bleed into the new one. The
-			* new thread's state (if any) is then populated below via
-			* `#applyValues`.
+			* Kick teardown so the synchronous abort (unbind, drop onEvent,
+			* close the root subscription, reset assemblers) runs before we
+			* touch the snapshot. Then reset immediately so the UI does not
+			* wait on pump/close. An interrupted thread parks the root pump
+			* on `waitForResume()`; awaiting teardown *before* this reset
+			* left `threadId` null while `messages` still showed the previous
+			* conversation (`useStream` fire-and-forgets `hydrate()`).
 			*/
+			const teardown = this.#teardownThread();
 			this.rootStore.setState(() => ({
 				...this.#createInitialSnapshot(),
 				threadId: this.#currentThreadId
@@ -408,6 +439,7 @@ var StreamController = class {
 			* surprising. Mirrors the legacy `StreamOrchestrator` behaviour.
 			*/
 			this.queueStore.setState(() => EMPTY_QUEUE);
+			await teardown;
 		}
 		if (this.#currentThreadId == null) {
 			this.rootStore.setState((s) => ({
@@ -549,7 +581,10 @@ var StreamController = class {
 					interrupts: activeInterrupts,
 					interrupt: activeInterrupts[0]
 				}));
-				if (this.#submitGeneration === generationAtFetch) this.#hydratedActiveInterruptIds = activeIds;
+				if (this.#submitGeneration === generationAtFetch) {
+					this.#hydratedActiveInterruptIds = activeIds;
+					this.#interruptReplayThroughSeq = void 0;
+				}
 			}
 		} catch (error) {
 			if (error?.status !== 404) {
@@ -996,9 +1031,11 @@ var StreamController = class {
 					config: options?.config,
 					metadata: options?.metadata
 				});
+				this.#advanceInterruptReplayBarrier();
 				this.#markInterruptResolvedInRootStore(resolved.interruptId);
 			}, prepared?.handle);
 		} catch (error) {
+			this.#discardPendingInterruptEvents();
 			if (this.#disposed && isAbortLikeError(error)) return;
 			throw error;
 		}
@@ -1065,9 +1102,11 @@ var StreamController = class {
 					config: options?.config,
 					metadata: options?.metadata
 				});
+				this.#advanceInterruptReplayBarrier();
 				for (const { interrupt_id: interruptId } of responses) this.#markInterruptResolvedInRootStore(interruptId);
 			}, prepared?.handle);
 		} catch (error) {
+			this.#discardPendingInterruptEvents();
 			if (this.#disposed && isAbortLikeError(error)) return;
 			throw error;
 		}
@@ -1235,6 +1274,14 @@ var StreamController = class {
 	* Close the current thread stream and reset per-thread assembly state.
 	*/
 	async #teardownThread() {
+		/**
+		* Invalidate the in-flight root pump before `close()` unparks it.
+		* `SubscriptionHandle.close()` leaves queued events intact and the
+		* iterator drains them before observing `closed`, so without this
+		* bump a parked interrupted pump would still dispatch stale
+		* `values` / `messages` into a snapshot `hydrate()` already cleared.
+		*/
+		this.#rootPumpGeneration += 1;
 		const thread = this.#thread;
 		this.#thread = void 0;
 		this.registry.bind(void 0);
@@ -1247,16 +1294,16 @@ var StreamController = class {
 		*/
 		this.#rootEventListeners.delete(this.#lifecycleLoading.listener);
 		this.#rootEventListeners.delete(this.#runLifecycleListener);
-		try {
-			await this.#rootSubscription?.unsubscribe();
-		} catch {}
+		/**
+		* Close first so a pump parked on `waitForResume()` (interrupted
+		* run) unparks even if the unsubscribe RPC is slow. `close()` is
+		* idempotent; `unsubscribe()` is then a no-op once closed.
+		*/
+		const subscription = this.#rootSubscription;
 		this.#rootSubscription = void 0;
+		subscription?.close();
 		this.#rootPumpReady = void 0;
 		this.#rootPumpDeferred = false;
-		try {
-			await this.#rootPump;
-		} catch {}
-		this.#rootPump = void 0;
 		this.#rootMessages.reset();
 		this.#rootToolAssembler = new ToolCallAssembler();
 		this.#lifecycleLoading.reset();
@@ -1267,7 +1314,16 @@ var StreamController = class {
 		this.#localRunDepth = 0;
 		this.#messageMetadata.reset();
 		this.#hydratedActiveInterruptIds = null;
+		this.#interruptReplayThroughSeq = void 0;
+		this.#discardPendingInterruptEvents();
 		this.queueStore.setState(() => EMPTY_QUEUE);
+		try {
+			await subscription?.unsubscribe();
+		} catch {}
+		try {
+			await this.#rootPump;
+		} catch {}
+		this.#rootPump = void 0;
 		if (thread != null) {
 			try {
 				await thread.close();
@@ -1291,6 +1347,7 @@ var StreamController = class {
 	*/
 	#startRootPump(thread) {
 		if (this.#rootPump != null) return;
+		const pumpGeneration = this.#rootPumpGeneration;
 		let resolveReady;
 		this.#rootPumpReady = new Promise((resolve) => {
 			resolveReady = resolve;
@@ -1349,6 +1406,14 @@ var StreamController = class {
 					resolveReady = void 0;
 				});
 				const subscription = await subscriptionPromise;
+				if (pumpGeneration !== this.#rootPumpGeneration) {
+					resolveReady?.();
+					resolveReady = void 0;
+					try {
+						subscription.close();
+					} catch {}
+					return;
+				}
 				resolveReady?.();
 				resolveReady = void 0;
 				this.#rootSubscription = subscription;
@@ -1362,9 +1427,9 @@ var StreamController = class {
 				* for every resumed iteration until the subscription is
 				* permanently closed or the controller is disposed.
 				*/
-				while (!this.#disposed) {
+				while (!this.#disposed && pumpGeneration === this.#rootPumpGeneration) {
 					for await (const event of subscription) {
-						if (this.#disposed) break;
+						if (this.#disposed || pumpGeneration !== this.#rootPumpGeneration) break;
 						/**
 						* Resilience: isolate per-event dispatch from the pump loop.
 						*
@@ -1396,7 +1461,7 @@ var StreamController = class {
 							this.#onRootEvent(event);
 						} catch {}
 					}
-					if (this.#disposed) break;
+					if (this.#disposed || pumpGeneration !== this.#rootPumpGeneration) break;
 					if (!subscription.isPaused) break;
 					await subscription.waitForResume();
 				}
@@ -1664,7 +1729,13 @@ var StreamController = class {
 		const data = event.params.data;
 		const interruptId = data?.interrupt_id;
 		if (typeof interruptId !== "string" || this.#resolvedInterrupts.has(interruptId)) return;
-		if (this.#hydratedActiveInterruptIds != null && !this.#hydratedActiveInterruptIds.has(interruptId)) return;
+		const eventSeq = typeof event.seq === "number" ? event.seq : void 0;
+		const isUnknownInterrupt = this.#hydratedActiveInterruptIds != null && !this.#hydratedActiveInterruptIds.has(interruptId);
+		if (isUnknownInterrupt && this.#interruptCommandPending) {
+			this.#pendingInterruptEvents.push(event);
+			return;
+		}
+		if (isUnknownInterrupt && (this.#interruptReplayThroughSeq == null || eventSeq != null && eventSeq <= this.#interruptReplayThroughSeq)) return;
 		const namespace = Array.isArray(event.params.namespace) ? [...event.params.namespace] : [...ROOT_NAMESPACE];
 		const interrupt = normalizeInterruptForClient({
 			id: interruptId,
@@ -1682,6 +1753,31 @@ var StreamController = class {
 		});
 	}
 	/**
+	* Convert the hydrate-time allowlist into a replay barrier after a command
+	* is accepted. Built-in transports update `lastAppliedThroughSeq` from the
+	* command response before resolving `submitRun` / `respondInput`.
+	*/
+	#advanceInterruptReplayBarrier() {
+		if (this.#hydratedActiveInterruptIds == null) {
+			this.#discardPendingInterruptEvents();
+			return;
+		}
+		const throughSeq = this.#thread?.ordering?.lastAppliedThroughSeq;
+		if (typeof throughSeq === "number") this.#interruptReplayThroughSeq = throughSeq;
+		else {
+			this.#hydratedActiveInterruptIds = null;
+			this.#interruptReplayThroughSeq = void 0;
+		}
+		this.#interruptCommandPending = false;
+		const pendingEvents = this.#pendingInterruptEvents;
+		this.#pendingInterruptEvents = [];
+		for (const event of pendingEvents) this.#recordInterrupt(event);
+	}
+	#discardPendingInterruptEvents() {
+		this.#interruptCommandPending = false;
+		this.#pendingInterruptEvents = [];
+	}
+	/**
 	* Resolve the protocol namespace for a targeted resume.
 	*
 	* Prefer an explicit caller-supplied namespace, then the matching