diff --git a/README.md b/README.md
index a602e49..230edd2 100644
--- a/README.md
+++ b/README.md
@@ -51,6 +51,7 @@ A library of JavaScript type extensions, types and type utilities.
     - [`<date>.setTimeStamp(..)`](#datesettimestamp)
   - [`String`](#string)
     - [`<string>.capitalize()`](#stringcapitalize)
+    - [`<string>.indent(..)`](#stringindent)
   - [`RegExp`](#regexp)
     - [`RegExp.quoteRegExp(..)`](#regexpquoteregexp)
   - [`Promise`](#promise)
@@ -107,18 +108,29 @@ A library of JavaScript type extensions, types and type utilities.
     - [`event.EventMixin`](#eventeventmixin)
   - [Runner](#runner)
     - [Micro task queue](#micro-task-queue)
+      - [`STOP`](#stop)
+      - [`SKIP`](#skip)
       - [`Queue(..)` / `Queue.runTasks(..)`](#queue--queueruntasks)
       - [`Queue.handle(..)`](#queuehandle)
       - [`<queue>.state`](#queuestate)
       - [`<queue>.start(..)`](#queuestart)
       - [`<queue>.stop(..)`](#queuestop)
-      - [`<queue>.then(..)`](#queuethen)
       - [`<queue>.runTask(..)`](#queueruntask)
       - [`<queue>.tasksAdded(..)` (event)](#queuetasksadded-event)
       - [`<queue>.taskStarting(..)` (event)](#queuetaskstarting-event)
       - [`<queue>.taskFailed(..)` (event)](#queuetaskfailed-event)
       - [`<queue>.taskCompleted(..)` (event)](#queuetaskcompleted-event)
       - [`<queue>.queueEmpty(..)` (event)](#queuequeueempty-event)
+      - [`<queue>.prioritize(..)`](#queueprioritize)
+      - [`<queue>.delay(..)`](#queuedelay)
+      - [`<queue>.add(..)`](#queueadd)
+      - [`<queue>.clear(..)`](#queueclear)
+      - [`FinalizableQueue(..)` / `FinalizableQueue.runTasks(..)` (Queue)](#finalizablequeue--finalizablequeueruntasks-queue)
+      - [`<finalizable-queue>.done(..)` (event/method)](#finalizable-queuedone-eventmethod)
+      - [`<finalizable-queue>.abort(..)` (event/method)](#finalizable-queueabort-eventmethod)
+      - [`<finalizable-queue>.promise(..)`](#finalizable-queuepromise)
+      - [`<finalizable-queue>.then(..)`](#finalizable-queuethen)
+      - [`<finalizable-queue>.catch(..)`](#finalizable-queuecatch)
     - [Large task management](#large-task-management)
       - [`runner.TaskManager(..)`](#runnertaskmanager)
       - [`<task-manager>.Task(..)`](#task-managertask)
@@ -769,6 +781,8 @@ require('ig-types/String')
 
 ### `<string>.capitalize()`
 
+### `<string>.indent(..)`
+
 
 ## `RegExp`
 
@@ -1166,6 +1180,11 @@ var runner = require('ig-types/runner')
 
 This includes [`event.EventMixin`](#eventeventmixin).
 
+#### `STOP`
+
+#### `SKIP`
+
+
 #### `Queue(..)` / `Queue.runTasks(..)`
 
 #### `Queue.handle(..)`
@@ -1189,6 +1208,9 @@ var handler_queue = Queue({
     .. )
 ```
 
+<!-- XXX settings... -->
+
+
 #### `<queue>.state`
 
 
@@ -1197,9 +1219,6 @@ var handler_queue = Queue({
 #### `<queue>.stop(..)`
 
 
-#### `<queue>.then(..)`
-
-
 #### `<queue>.runTask(..)`
 
 
@@ -1217,6 +1236,43 @@ Event, triggered when a task is completed passing in its result.
 #### `<queue>.queueEmpty(..)` (event)
 
 
+#### `<queue>.prioritize(..)`
+
+#### `<queue>.delay(..)`
+
+
+#### `<queue>.add(..)`
+
+#### `<queue>.clear(..)`
+
+
+
+#### `FinalizableQueue(..)` / `FinalizableQueue.runTasks(..)` (Queue)
+
+This is the similar as `Queue(..)` but adds two terminal states (`"done"` 
+and `"aborted"`) and a `promise`-mapping.
+
+```bnf
+FinalizableQueue.handle(<func>, ...<data>)
+FinalizableQueue.handle(<options>, <func>, ...<data>)
+    -> <finalizable-queue>
+```
+
+When a `<finalizable-queue>` reaches a terminal state it is frozen.
+
+#### `<finalizable-queue>.done(..)` (event/method)
+
+#### `<finalizable-queue>.abort(..)` (event/method)
+
+
+#### `<finalizable-queue>.promise(..)`
+
+#### `<finalizable-queue>.then(..)`
+
+#### `<finalizable-queue>.catch(..)`
+
+
+
 
 ### Large task management
 
@@ -1263,4 +1319,4 @@ Copyright (c) 2020, Alex A. Naanou,
 All rights reserved.
 
 
-<!-- vim:set ts=4 sw=4 spell : -->
+<!-- vim:set ts=4 sw=4 spell : -->
\ No newline at end of file
diff --git a/String.js b/String.js
index 9bfb46a..8bda555 100644
--- a/String.js
+++ b/String.js
@@ -19,6 +19,16 @@ object.Mixin('StringProtoMixin', 'soft', {
 		return this == '' ? 
 			this 
 			: this[0].toUpperCase() + this.slice(1) },
+
+	//
+	// 	.indent(<width>)
+	// 	.indent(<str>)
+	//
+	indent: function(indent){
+		indent = typeof(indent) == typeof('str') ?
+			indent
+			: ' '.repeat(indent)
+		return indent + this.split(/\n/).join('\n'+ indent) },
 })
 
 
diff --git a/package.json b/package.json
index 4e6d860..6b23c83 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ig-types",
-  "version": "6.0.1",
+  "version": "6.0.4",
   "description": "Generic JavaScript types and type extensions...",
   "main": "main.js",
   "scripts": {
diff --git a/runner.js b/runner.js
index 3a2aa46..a180167 100644
--- a/runner.js
+++ b/runner.js
@@ -31,6 +31,7 @@ var events = require('./event')
 
 module.STOP = object.STOP
 
+module.SKIP = {doc: 'skip queue item',}
 
 
 //---------------------------------------------------------------------
@@ -179,10 +180,10 @@ object.Constructor('Queue', Array, {
 	//
 	// NOTE: to start synchronously call .start(true), this will not 
 	// 		affect further operation...
+	//
 	// XXX would be nice to run a specific number of tasks and stop...
-	// XXX if starting empty need to start the timer only when something is 
-	// 		added...
 	// XXX might be a good idea to let the user set .__wait_for_items...
+	// XXX should we wait for items on empty?
 	__wait_for_items: null,
 	start: events.Event('start', function(handle, sync){
 		// first start -- wait for items...
@@ -220,6 +221,7 @@ object.Constructor('Queue', Array, {
 	//	.handler(task[, next])
 	//		-> STOP
 	//		-> STOP(value)
+	//		-> SKIP
 	//		-> queue
 	//		-> promise
 	//		-> func
@@ -410,6 +412,7 @@ object.Constructor('Queue', Array, {
 
 		// collect results...
 		this.collect_results
+			&& res !== module.SKIP
 			&& (this.__results = this.__results || []).push(res)
 
 		// handle task results...
@@ -535,8 +538,11 @@ object.Constructor('Queue', Array, {
 }))
 
 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
 // Like Queue(..) but adds terminal states and conversion to promises...
 //
+// XXX should this .freeze()??/
 // XXX find a better name...
 var FinalizableQueue =
 module.FinalizableQueue =
@@ -546,7 +552,6 @@ object.Constructor('FinalizableQueue', Queue, {
 	__onempty__: function(){
 		return this.trigger('done') },
 
-	// XXX sould these freeze???
 	done: events.Event('done', function(handle){
 		// abort only once...
 		if(this.state == 'aborted' || this.state == 'done'){
@@ -562,7 +567,6 @@ object.Constructor('FinalizableQueue', Queue, {
 
 	// NOTE: each handler will get called once when the next time the 
 	// 		queue is emptied...
-	// XXX should this trigger on empty or on stop???
 	promise: function(){
 		var that = this
 		return new Promise(function(resolve, reject){