Add comprehensive installation and setup documentation

- Add GETTING_STARTED.md with quick start guide and development modes
- Add INSTALL.sh automated installation script
- Add INSTALLATION_CHECKLIST.md, INSTALLATION_SUCCESS.md, and INSTALLATION_SUMMARY.md
- Add QUICK_REFERENCE.md for common commands
- Add SETUP_GUIDE.md with detailed setup instructions
- Update README.md with improved project overview
- Add did-wallet app dependencies and node_modules

apps/web5-dwn/node_modules/it-pipe/LICENSE

@@ -0,0 +1,4 @@
+This project is dual licensed under MIT and Apache-2.0.
+
+MIT: https://www.opensource.org/licenses/mit
+Apache-2.0: https://www.apache.org/licenses/license-2.0

apps/web5-dwn/node_modules/it-pipe/README.md

@@ -0,0 +1,90 @@
+# it-pipe <!-- omit in toc -->
+
+[![codecov](https://img.shields.io/codecov/c/github/alanshaw/it-pipe.svg?style=flat-square)](https://codecov.io/gh/alanshaw/it-pipe)
+[![CI](https://img.shields.io/github/actions/workflow/status/alanshaw/it-pipe/js-test-and-release.yml?branch=master\&style=flat-square)](https://github.com/alanshaw/it-pipe/actions/workflows/js-test-and-release.yml?query=branch%3Amaster)
+
+> Utility to "pipe" async iterables together
+
+## Table of contents <!-- omit in toc -->
+
+- [Install](#install)
+  - [Browser `<script>` tag](#browser-script-tag)
+- [Usage](#usage)
+- [API](#api)
+  - [`pipe(firstFn, ...fns)`](#pipefirstfn-fns)
+- [API Docs](#api-docs)
+- [License](#license)
+- [Contribution](#contribution)
+
+## Install
+
+```console
+$ npm i it-pipe
+```
+
+### Browser `<script>` tag
+
+Loading this module through a script tag will make it's exports available as `ItPipe` in the global namespace.
+
+```html
+<script src="https://unpkg.com/it-pipe/dist/index.min.js"></script>
+```
+
+Based on this definition of streaming iterables <https://gist.github.com/alanshaw/591dc7dd54e4f99338a347ef568d6ee9>.
+
+Almost identical to the [`pipeline`](https://github.com/bustle/streaming-iterables#pipeline) function from the [`streaming-iterables`](https://www.npmjs.com/package/streaming-iterables) module except that it supports duplex streams *and* will automatically wrap a "source" as the first param in a function.
+
+## Usage
+
+```js
+import { pipe } from 'it-pipe'
+
+const result = await pipe(
+  // A source is just an iterable, this is shorthand for () => [1, 2, 3]
+  [1, 2, 3],
+  // A transform takes a source, and returns a source.
+  // This transform doubles each value asynchronously.
+  function transform (source) {
+    return (async function * () { // A generator is async iterable
+      for await (const val of source) yield val * 2
+    })()
+  },
+  // A sink, it takes a source and consumes it, optionally returning a value.
+  // This sink buffers up all the values from the source and returns them.
+  async function collect (source) {
+    const vals = []
+    for await (const val of source) {
+      vals.push(val)
+    }
+    return vals
+  }
+)
+
+console.log(result) // 2,4,6
+```
+
+## API
+
+### `pipe(firstFn, ...fns)`
+
+Calls `firstFn` and then every function in `fns` with the result of the previous function. The final return is the result of the last function in `fns`.
+
+Note:
+
+- `firstFn` may be a `Function` or an `Iterable`
+- `firstFn` or any of `fns` may be a [duplex object](https://gist.github.com/alanshaw/591dc7dd54e4f99338a347ef568d6ee9#duplex-it) (an object with a `sink` and `source`).
+
+## API Docs
+
+- <https://alanshaw.github.io/it-pipe>
+
+## License
+
+Licensed under either of
+
+- Apache 2.0, ([LICENSE-APACHE](LICENSE-APACHE) / <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT ([LICENSE-MIT](LICENSE-MIT) / <http://opensource.org/licenses/MIT>)
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

apps/web5-dwn/node_modules/it-pipe/dist/index.min.js

@@ -0,0 +1,3 @@
+(function (root, factory) {(typeof module === 'object' && module.exports) ? module.exports = factory() : root.ItPipe = factory()}(typeof self !== 'undefined' ? self : this, function () {
+"use strict";var ItPipe=(()=>{var d=Object.defineProperty;var N=Object.getOwnPropertyDescriptor;var A=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var P=(n,e)=>{for(var t in e)d(n,t,{get:e[t],enumerable:!0})},_=(n,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let u of A(e))!M.call(n,u)&&u!==t&&d(n,u,{get:()=>e[u],enumerable:!(r=N(e,u))||r.enumerable});return n};var U=n=>_(d({},"__esModule",{value:!0}),n);var q={};P(q,{pipe:()=>V,rawPipe:()=>w});var a=class{constructor(e){if(!(e>0)||e-1&e)throw new Error("Max size for a FixedFIFO should be a power of two");this.buffer=new Array(e),this.mask=e-1,this.top=0,this.btm=0,this.next=null}push(e){return this.buffer[this.top]!==void 0?!1:(this.buffer[this.top]=e,this.top=this.top+1&this.mask,!0)}shift(){let e=this.buffer[this.btm];if(e!==void 0)return this.buffer[this.btm]=void 0,this.btm=this.btm+1&this.mask,e}isEmpty(){return this.buffer[this.btm]===void 0}},l=class{constructor(e={}){this.hwm=e.splitLimit??16,this.head=new a(this.hwm),this.tail=this.head,this.size=0}calculateSize(e){return e?.byteLength!=null?e.byteLength:1}push(e){if(e?.value!=null&&(this.size+=this.calculateSize(e.value)),!this.head.push(e)){let t=this.head;this.head=t.next=new a(2*this.head.buffer.length),this.head.push(e)}}shift(){let e=this.tail.shift();if(e===void 0&&this.tail.next!=null){let t=this.tail.next;this.tail.next=null,this.tail=t,e=this.tail.shift()}return e?.value!=null&&(this.size-=this.calculateSize(e.value)),e}isEmpty(){return this.head.isEmpty()}};function f(n={}){return j(t=>{let r=t.shift();if(r==null)return{done:!0};if(r.error!=null)throw r.error;return{done:r.done===!0,value:r.value}},n)}function j(n,e){e=e??{};let t=e.onEnd,r=new l,u,s,o,E=async()=>r.isEmpty()?o?{done:!0}:await new Promise((i,k)=>{s=z=>{s=null,r.push(z);try{i(n(r))}catch(L){k(L)}return u}}):n(r),b=i=>s!=null?s(i):(r.push(i),u),v=i=>(r=new l,s!=null?s({error:i}):(r.push({error:i}),u)),m=i=>{if(o)return u;if(e?.objectMode!==!0&&i?.byteLength==null)throw new Error("objectMode was not true but tried to push non-Uint8Array value");return b({done:!1,value:i})},c=i=>o?u:(o=!0,i!=null?v(i):b({done:!0})),I=()=>(r=new l,c(),{done:!0}),S=i=>(c(i),{done:!0});if(u={[Symbol.asyncIterator](){return this},next:E,return:I,throw:S,push:m,end:c,get readableLength(){return r.size}},t==null)return u;let h=u;return u={[Symbol.asyncIterator](){return this},next(){return h.next()},throw(i){return h.throw(i),t!=null&&(t(i),t=void 0),{done:!0}},return(){return h.return(),t!=null&&(t(),t=void 0),{done:!0}},push:m,end(i){return h.end(i),t!=null&&(t(i),t=void 0),u},get readableLength(){return h.readableLength}},u}function D(n){return n[Symbol.asyncIterator]!=null}function F(...n){let e=[];for(let t of n)D(t)||e.push(t);return e.length===n.length?function*(){for(let t of e)yield*t}():async function*(){let t=f({objectMode:!0});Promise.resolve().then(async()=>{try{await Promise.all(n.map(async r=>{for await(let u of r)t.push(u)})),t.end()}catch(r){t.end(r)}}),yield*t}()}var y=F;function V(n,...e){if(n==null)throw new Error("Empty pipeline");if(p(n)){let r=n;n=()=>r.source}else if(g(n)||x(n)){let r=n;n=()=>r}let t=[n,...e];if(t.length>1&&p(t[t.length-1])&&(t[t.length-1]=t[t.length-1].sink),t.length>2)for(let r=1;r<t.length-1;r++)p(t[r])&&(t[r]=W(t[r]));return w(...t)}var w=(...n)=>{let e;for(;n.length>0;)e=n.shift()(e);return e},x=n=>n?.[Symbol.asyncIterator]!=null,g=n=>n?.[Symbol.iterator]!=null,p=n=>n==null?!1:n.sink!=null&&n.source!=null,W=n=>e=>{let t=n.sink(e);if(t?.then!=null){let r=f({objectMode:!0});t.then(()=>{r.end()},o=>{r.end(o)});let u,s=n.source;if(x(s))u=async function*(){yield*s,r.end()};else if(g(s))u=function*(){yield*s,r.end()};else throw new Error("Unknown duplex source type - must be Iterable or AsyncIterable");return y(r,u())}return n.source};return U(q);})();
+return ItPipe}));

apps/web5-dwn/node_modules/it-pipe/dist/src/index.d.ts

@@ -0,0 +1,25 @@
+import type { Duplex, Transform, Sink } from 'it-stream-types';
+interface SourceFn<A = any> {
+    (): A;
+}
+type PipeSource<A = any> = Iterable<A> | AsyncIterable<A> | SourceFn<A> | Duplex<A, any, any>;
+type PipeTransform<A = any, B = any> = Transform<A, B> | Duplex<B, A>;
+type PipeSink<A = any, B = any> = Sink<A, B> | Duplex<any, A, B>;
+type PipeOutput<A> = A extends Sink<any> ? ReturnType<A> : A extends Duplex<any, any, any> ? ReturnType<A['sink']> : never;
+type SingleItemPipeOutput<A> = A extends Iterable<any> ? A : A extends AsyncIterable<any> ? A : A extends SourceFn ? ReturnType<A> : A extends Duplex<any, any, any> ? A['source'] : PipeOutput<A>;
+type PipeFnInput<A> = A extends Iterable<any> ? A : A extends AsyncIterable<any> ? A : A extends SourceFn ? ReturnType<A> : A extends Transform<any, any> ? ReturnType<A> : A extends Duplex<any, any, any> ? A['source'] : never;
+export declare function pipe<A extends PipeSource>(source: A): SingleItemPipeOutput<A>;
+export declare function pipe<A extends PipeSource, B extends PipeSink<PipeFnInput<A>>>(source: A, sink: B): PipeOutput<B>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeSink<PipeFnInput<B>>>(source: A, transform1: B, sink: C): PipeOutput<C>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeSink<PipeFnInput<C>>>(source: A, transform1: B, transform2: C, sink: D): PipeOutput<D>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeTransform<PipeFnInput<C>>, E extends PipeSink<PipeFnInput<D>>>(source: A, transform1: B, transform2: C, transform3: D, sink: E): PipeOutput<E>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeTransform<PipeFnInput<C>>, E extends PipeTransform<PipeFnInput<D>>, F extends PipeSink<PipeFnInput<E>>>(source: A, transform1: B, transform2: C, transform3: D, transform4: E, sink: F): PipeOutput<F>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeTransform<PipeFnInput<C>>, E extends PipeTransform<PipeFnInput<D>>, F extends PipeTransform<PipeFnInput<E>>, G extends PipeSink<PipeFnInput<F>>>(source: A, transform1: B, transform2: C, transform3: D, transform4: E, transform5: F, sink: G): PipeOutput<G>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeTransform<PipeFnInput<C>>, E extends PipeTransform<PipeFnInput<D>>, F extends PipeTransform<PipeFnInput<E>>, G extends PipeTransform<PipeFnInput<F>>, H extends PipeSink<PipeFnInput<G>>>(source: A, transform1: B, transform2: C, transform3: D, transform4: E, transform5: F, transform6: G, sink: H): PipeOutput<H>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeTransform<PipeFnInput<C>>, E extends PipeTransform<PipeFnInput<D>>, F extends PipeTransform<PipeFnInput<E>>, G extends PipeTransform<PipeFnInput<F>>, H extends PipeTransform<PipeFnInput<G>>, I extends PipeSink<PipeFnInput<H>>>(source: A, transform1: B, transform2: C, transform3: D, transform4: E, transform5: F, transform6: G, transform7: H, sink: I): PipeOutput<I>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeTransform<PipeFnInput<C>>, E extends PipeTransform<PipeFnInput<D>>, F extends PipeTransform<PipeFnInput<E>>, G extends PipeTransform<PipeFnInput<F>>, H extends PipeTransform<PipeFnInput<G>>, I extends PipeTransform<PipeFnInput<H>>, J extends PipeSink<PipeFnInput<I>>>(source: A, transform1: B, transform2: C, transform3: D, transform4: E, transform5: F, transform6: G, transform7: H, transform8: I, sink: J): PipeOutput<J>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeTransform<PipeFnInput<C>>, E extends PipeTransform<PipeFnInput<D>>, F extends PipeTransform<PipeFnInput<E>>, G extends PipeTransform<PipeFnInput<F>>, H extends PipeTransform<PipeFnInput<G>>, I extends PipeTransform<PipeFnInput<H>>, J extends PipeTransform<PipeFnInput<I>>, K extends PipeSink<PipeFnInput<J>>>(source: A, transform1: B, transform2: C, transform3: D, transform4: E, transform5: F, transform6: G, transform7: H, transform8: I, transform9: J, sink: K): PipeOutput<K>;
+export declare function pipe<A extends PipeSource, B extends PipeTransform<PipeFnInput<A>>, C extends PipeTransform<PipeFnInput<B>>, D extends PipeTransform<PipeFnInput<C>>, E extends PipeTransform<PipeFnInput<D>>, F extends PipeTransform<PipeFnInput<E>>, G extends PipeTransform<PipeFnInput<F>>, H extends PipeTransform<PipeFnInput<G>>, I extends PipeTransform<PipeFnInput<H>>, J extends PipeTransform<PipeFnInput<I>>, K extends PipeTransform<PipeFnInput<J>>, L extends PipeSink<PipeFnInput<K>>>(source: A, transform1: B, transform2: C, transform3: D, transform4: E, transform5: F, transform6: G, transform7: H, transform8: I, transform9: J, transform10: K, sink: L): PipeOutput<L>;
+export declare const rawPipe: (...fns: any) => any;
+export {};
+//# sourceMappingURL=index.d.ts.map

apps/web5-dwn/node_modules/it-pipe/dist/src/index.js

@@ -0,0 +1,87 @@
+import { pushable } from 'it-pushable';
+import merge from 'it-merge';
+export function pipe(first, ...rest) {
+    if (first == null) {
+        throw new Error('Empty pipeline');
+    }
+    // Duplex at start: wrap in function and return duplex source
+    if (isDuplex(first)) {
+        const duplex = first;
+        first = () => duplex.source;
+        // Iterable at start: wrap in function
+    }
+    else if (isIterable(first) || isAsyncIterable(first)) {
+        const source = first;
+        first = () => source;
+    }
+    const fns = [first, ...rest];
+    if (fns.length > 1) {
+        // Duplex at end: use duplex sink
+        if (isDuplex(fns[fns.length - 1])) {
+            fns[fns.length - 1] = fns[fns.length - 1].sink;
+        }
+    }
+    if (fns.length > 2) {
+        // Duplex in the middle, consume source with duplex sink and return duplex source
+        for (let i = 1; i < fns.length - 1; i++) {
+            if (isDuplex(fns[i])) {
+                fns[i] = duplexPipelineFn(fns[i]);
+            }
+        }
+    }
+    return rawPipe(...fns);
+}
+export const rawPipe = (...fns) => {
+    let res;
+    while (fns.length > 0) {
+        res = fns.shift()(res);
+    }
+    return res;
+};
+const isAsyncIterable = (obj) => {
+    return obj?.[Symbol.asyncIterator] != null;
+};
+const isIterable = (obj) => {
+    return obj?.[Symbol.iterator] != null;
+};
+const isDuplex = (obj) => {
+    if (obj == null) {
+        return false;
+    }
+    return obj.sink != null && obj.source != null;
+};
+const duplexPipelineFn = (duplex) => {
+    return (source) => {
+        const p = duplex.sink(source);
+        if (p?.then != null) {
+            const stream = pushable({
+                objectMode: true
+            });
+            p.then(() => {
+                stream.end();
+            }, (err) => {
+                stream.end(err);
+            });
+            let sourceWrap;
+            const source = duplex.source;
+            if (isAsyncIterable(source)) {
+                sourceWrap = async function* () {
+                    yield* source;
+                    stream.end();
+                };
+            }
+            else if (isIterable(source)) {
+                sourceWrap = function* () {
+                    yield* source;
+                    stream.end();
+                };
+            }
+            else {
+                throw new Error('Unknown duplex source type - must be Iterable or AsyncIterable');
+            }
+            return merge(stream, sourceWrap());
+        }
+        return duplex.source;
+    };
+};
+//# sourceMappingURL=index.js.map

apps/web5-dwn/node_modules/it-pipe/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

apps/web5-dwn/node_modules/it-pipe/dist/typedoc-urls.json

@@ -0,0 +1,11 @@
+{
+  "SourceFn": "https://alanshaw.github.io/it-pipe/interfaces/_internal_.SourceFn.html",
+  "PipeFnInput": "https://alanshaw.github.io/it-pipe/types/_internal_.PipeFnInput.html",
+  "PipeOutput": "https://alanshaw.github.io/it-pipe/types/_internal_.PipeOutput.html",
+  "PipeSink": "https://alanshaw.github.io/it-pipe/types/_internal_.PipeSink.html",
+  "PipeSource": "https://alanshaw.github.io/it-pipe/types/_internal_.PipeSource.html",
+  "PipeTransform": "https://alanshaw.github.io/it-pipe/types/_internal_.PipeTransform.html",
+  "SingleItemPipeOutput": "https://alanshaw.github.io/it-pipe/types/_internal_.SingleItemPipeOutput.html",
+  "pipe": "https://alanshaw.github.io/it-pipe/functions/pipe.html",
+  "rawPipe": "https://alanshaw.github.io/it-pipe/functions/rawPipe.html"
+}

apps/web5-dwn/node_modules/it-pipe/package.json

@@ -0,0 +1,164 @@
+{
+  "name": "it-pipe",
+  "version": "3.0.1",
+  "description": "Utility to \"pipe\" async iterables together",
+  "author": "Alan Shaw",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/alanshaw/it-pipe#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alanshaw/it-pipe.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alanshaw/it-pipe/issues"
+  },
+  "keywords": [
+    "async",
+    "await",
+    "iterable",
+    "iterator",
+    "pipe",
+    "pipeline",
+    "pull",
+    "pump",
+    "stream"
+  ],
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=7.0.0"
+  },
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "sourceType": "module"
+    }
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "type": "deps",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Documentation"
+              },
+              {
+                "type": "deps",
+                "section": "Dependencies"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  },
+  "scripts": {
+    "clean": "aegir clean",
+    "lint": "aegir lint",
+    "dep-check": "aegir dep-check",
+    "build": "aegir build",
+    "test": "aegir test",
+    "test:chrome": "aegir test -t browser --cov",
+    "test:chrome-webworker": "aegir test -t webworker",
+    "test:firefox": "aegir test -t browser -- --browser firefox",
+    "test:firefox-webworker": "aegir test -t webworker -- --browser firefox",
+    "test:node": "aegir test -t node --cov",
+    "test:electron-main": "aegir test -t electron-main",
+    "release": "aegir release",
+    "docs": "aegir docs"
+  },
+  "dependencies": {
+    "it-merge": "^3.0.0",
+    "it-pushable": "^3.1.2",
+    "it-stream-types": "^2.0.1"
+  },
+  "devDependencies": {
+    "aegir": "^38.1.8",
+    "delay": "^5.0.0",
+    "it-all": "^3.0.1",
+    "it-drain": "^3.0.1",
+    "it-map": "^3.0.2",
+    "p-defer": "^4.0.0",
+    "streaming-iterables": "^7.0.4"
+  }
+}

apps/web5-dwn/node_modules/it-pipe/src/index.ts

@@ -0,0 +1,354 @@
+import { pushable } from 'it-pushable'
+import merge from 'it-merge'
+import type { Duplex, Transform, Sink } from 'it-stream-types'
+
+interface SourceFn<A = any> { (): A }
+
+type PipeSource<A = any> =
+  Iterable<A> |
+  AsyncIterable<A> |
+  SourceFn<A> |
+  Duplex<A, any, any>
+
+type PipeTransform<A = any, B = any> =
+  Transform<A, B> |
+  Duplex<B, A>
+
+type PipeSink<A = any, B = any> =
+  Sink<A, B> |
+  Duplex<any, A, B>
+
+type PipeOutput<A> =
+  A extends Sink<any> ? ReturnType<A> :
+    A extends Duplex<any, any, any> ? ReturnType<A['sink']> :
+      never
+
+// single item pipe output includes pipe source types
+type SingleItemPipeOutput<A> =
+  A extends Iterable<any> ? A :
+    A extends AsyncIterable<any> ? A :
+      A extends SourceFn ? ReturnType<A> :
+        A extends Duplex<any, any, any> ? A['source'] :
+          PipeOutput<A>
+
+type PipeFnInput<A> =
+  A extends Iterable<any> ? A :
+    A extends AsyncIterable<any> ? A :
+      A extends SourceFn ? ReturnType<A> :
+        A extends Transform<any, any> ? ReturnType<A> :
+          A extends Duplex<any, any, any> ? A['source'] :
+            never
+
+// one item, just a pass-through
+export function pipe<
+  A extends PipeSource
+> (
+  source: A
+): SingleItemPipeOutput<A>
+
+// two items, source to sink
+export function pipe<
+  A extends PipeSource,
+  B extends PipeSink<PipeFnInput<A>>
+> (
+  source: A,
+  sink: B
+): PipeOutput<B>
+
+// three items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeSink<PipeFnInput<B>>
+> (
+  source: A,
+  transform1: B,
+  sink: C
+): PipeOutput<C>
+
+// many items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeSink<PipeFnInput<C>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  sink: D
+): PipeOutput<D>
+
+// lots of items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeTransform<PipeFnInput<C>>,
+  E extends PipeSink<PipeFnInput<D>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  transform3: D,
+  sink: E
+): PipeOutput<E>
+
+// lots of items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeTransform<PipeFnInput<C>>,
+  E extends PipeTransform<PipeFnInput<D>>,
+  F extends PipeSink<PipeFnInput<E>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  transform3: D,
+  transform4: E,
+  sink: F
+): PipeOutput<F>
+
+// lots of items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeTransform<PipeFnInput<C>>,
+  E extends PipeTransform<PipeFnInput<D>>,
+  F extends PipeTransform<PipeFnInput<E>>,
+  G extends PipeSink<PipeFnInput<F>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  transform3: D,
+  transform4: E,
+  transform5: F,
+  sink: G
+): PipeOutput<G>
+
+// lots of items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeTransform<PipeFnInput<C>>,
+  E extends PipeTransform<PipeFnInput<D>>,
+  F extends PipeTransform<PipeFnInput<E>>,
+  G extends PipeTransform<PipeFnInput<F>>,
+  H extends PipeSink<PipeFnInput<G>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  transform3: D,
+  transform4: E,
+  transform5: F,
+  transform6: G,
+  sink: H
+): PipeOutput<H>
+
+// lots of items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeTransform<PipeFnInput<C>>,
+  E extends PipeTransform<PipeFnInput<D>>,
+  F extends PipeTransform<PipeFnInput<E>>,
+  G extends PipeTransform<PipeFnInput<F>>,
+  H extends PipeTransform<PipeFnInput<G>>,
+  I extends PipeSink<PipeFnInput<H>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  transform3: D,
+  transform4: E,
+  transform5: F,
+  transform6: G,
+  transform7: H,
+  sink: I
+): PipeOutput<I>
+
+// lots of items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeTransform<PipeFnInput<C>>,
+  E extends PipeTransform<PipeFnInput<D>>,
+  F extends PipeTransform<PipeFnInput<E>>,
+  G extends PipeTransform<PipeFnInput<F>>,
+  H extends PipeTransform<PipeFnInput<G>>,
+  I extends PipeTransform<PipeFnInput<H>>,
+  J extends PipeSink<PipeFnInput<I>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  transform3: D,
+  transform4: E,
+  transform5: F,
+  transform6: G,
+  transform7: H,
+  transform8: I,
+  sink: J
+): PipeOutput<J>
+
+// lots of items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeTransform<PipeFnInput<C>>,
+  E extends PipeTransform<PipeFnInput<D>>,
+  F extends PipeTransform<PipeFnInput<E>>,
+  G extends PipeTransform<PipeFnInput<F>>,
+  H extends PipeTransform<PipeFnInput<G>>,
+  I extends PipeTransform<PipeFnInput<H>>,
+  J extends PipeTransform<PipeFnInput<I>>,
+  K extends PipeSink<PipeFnInput<J>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  transform3: D,
+  transform4: E,
+  transform5: F,
+  transform6: G,
+  transform7: H,
+  transform8: I,
+  transform9: J,
+  sink: K
+): PipeOutput<K>
+
+// lots of items, source to sink with transform(s) in between
+export function pipe<
+  A extends PipeSource,
+  B extends PipeTransform<PipeFnInput<A>>,
+  C extends PipeTransform<PipeFnInput<B>>,
+  D extends PipeTransform<PipeFnInput<C>>,
+  E extends PipeTransform<PipeFnInput<D>>,
+  F extends PipeTransform<PipeFnInput<E>>,
+  G extends PipeTransform<PipeFnInput<F>>,
+  H extends PipeTransform<PipeFnInput<G>>,
+  I extends PipeTransform<PipeFnInput<H>>,
+  J extends PipeTransform<PipeFnInput<I>>,
+  K extends PipeTransform<PipeFnInput<J>>,
+  L extends PipeSink<PipeFnInput<K>>
+> (
+  source: A,
+  transform1: B,
+  transform2: C,
+  transform3: D,
+  transform4: E,
+  transform5: F,
+  transform6: G,
+  transform7: H,
+  transform8: I,
+  transform9: J,
+  transform10: K,
+  sink: L
+): PipeOutput<L>
+
+export function pipe (first: any, ...rest: any[]): any {
+  if (first == null) {
+    throw new Error('Empty pipeline')
+  }
+
+  // Duplex at start: wrap in function and return duplex source
+  if (isDuplex(first)) {
+    const duplex = first
+    first = () => duplex.source
+  // Iterable at start: wrap in function
+  } else if (isIterable(first) || isAsyncIterable(first)) {
+    const source = first
+    first = () => source
+  }
+
+  const fns = [first, ...rest]
+
+  if (fns.length > 1) {
+    // Duplex at end: use duplex sink
+    if (isDuplex(fns[fns.length - 1])) {
+      fns[fns.length - 1] = fns[fns.length - 1].sink
+    }
+  }
+
+  if (fns.length > 2) {
+    // Duplex in the middle, consume source with duplex sink and return duplex source
+    for (let i = 1; i < fns.length - 1; i++) {
+      if (isDuplex(fns[i])) {
+        fns[i] = duplexPipelineFn(fns[i])
+      }
+    }
+  }
+
+  return rawPipe(...fns)
+}
+
+export const rawPipe = (...fns: any): any => {
+  let res
+  while (fns.length > 0) {
+    res = fns.shift()(res)
+  }
+  return res
+}
+
+const isAsyncIterable = (obj: any): obj is AsyncIterable<unknown> => {
+  return obj?.[Symbol.asyncIterator] != null
+}
+
+const isIterable = (obj: any): obj is Iterable<unknown> => {
+  return obj?.[Symbol.iterator] != null
+}
+
+const isDuplex = (obj: any): obj is Duplex => {
+  if (obj == null) {
+    return false
+  }
+
+  return obj.sink != null && obj.source != null
+}
+
+const duplexPipelineFn = (duplex: Duplex<any, any, any>) => {
+  return (source: any) => {
+    const p = duplex.sink(source)
+
+    if (p?.then != null) {
+      const stream = pushable<any>({
+        objectMode: true
+      })
+      p.then(() => {
+        stream.end()
+      }, (err: Error) => {
+        stream.end(err)
+      })
+
+      let sourceWrap: () => Iterable<any> | AsyncIterable<any>
+      const source = duplex.source
+
+      if (isAsyncIterable(source)) {
+        sourceWrap = async function * () {
+          yield * source
+          stream.end()
+        }
+      } else if (isIterable(source)) {
+        sourceWrap = function * () {
+          yield * source
+          stream.end()
+        }
+      } else {
+        throw new Error('Unknown duplex source type - must be Iterable or AsyncIterable')
+      }
+
+      return merge(stream, sourceWrap())
+    }
+
+    return duplex.source
+  }
+}