ipfs · Sep 14, 2014 · Sep 14, 2014 · Sep 14, 2014 · Sep 14, 2014 · Sep 15, 2014
Showing 2,006 changed files with 172,743 additions and 87,423 deletions.
diff --git a/.aegir.js b/.aegir.js
diff --git a/.dockerignore b/.dockerignore
@@ -1 +1,2 @@
-node_modules/
+*
+
diff --git a/.gitattributes b/.gitattributes
@@ -1,6 +1,7 @@
 * text=auto
-test/** text eol=lf
-src/init-files/** text eol=lf
+**/test/fixtures/** text eol=lf
+**/test/gateway/** text eol=lf
+**/src/init-files/** text eol=lf
 
 *.data binary
 *.png binary

diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+ - name: Getting Help on IPFS
+   url: https://ipfs.io/help
+   about: All information about how and where to get help on IPFS
+ - name: IPFS Official Forum
+   url: https://discuss.ipfs.io
+   about: For general questions, support requests and discussions
diff --git a/.github/ISSUE_TEMPLATE/open_an_issue.md b/.github/ISSUE_TEMPLATE/open_an_issue.md
@@ -0,0 +1,55 @@
+---
+name: Open an issue
+about: For reporting bugs or errors in the JavaScript IPFS implementation
+title: ''
+labels: need/triage
+assignees: ''
+---
+
+<!--
+Thank you for reporting an issue.
+
+This issue tracker is for bugs found within the JavaScript implementation of IPFS.
+
+If you are asking a question about how to use IPFS, please ask on https://discuss.ipfs.io
+
+Otherwise please fill in as much of the template below as possible.
+-->
+
+- **Version**:
+<!--
+Output of `jsipfs version --all` if using the CLI or `await ipfs.version()` if using the instance
+-->
+
+- **Platform**:
+<!--
+Output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows). If using in a Browser, please share the browser version as well
+-->
+
+- **Subsystem**:
+<!--
+If known, please specify affected core module name (e.g Bitswap, libp2p, etc)
+-->
+
+#### Severity:
+<!--
+One of following:
+  Critical - System crash, application panic.
+  High - The main functionality of the application does not work, API breakage, repo format breakage, etc.
+  Medium - A non-essential functionality does not work, performance issues, etc.
+  Low - An optional functionality does not work.
+  Very Low - Translation or documentation mistake. Something that won't give anyone a bad day.
+-->
+
+#### Description:
+<!--
+- What you did
+- What happened
+- What you expected to happen
+-->
+
+#### Steps to reproduce the error:
+<!--
+If possible, please provide code that demonstrates the problem, keeping it as simple and free of external dependencies as you are able
+-->
+
diff --git a/.github/config.yml b/.github/config.yml
@@ -0,0 +1,68 @@
+# Configuration for welcome - https://github.com/behaviorbot/welcome
+
+# Configuration for new-issue-welcome - https://github.com/behaviorbot/new-issue-welcome
+# Comment to be posted to on first time issues
+newIssueWelcomeComment: >
+  Thank you for submitting your first issue to this repository! A maintainer
+  will be here shortly to triage and review.
+
+  In the meantime, please double-check that you have provided all the
+  necessary information to make this process easy! Any information that can
+  help save additional round trips is useful! We currently aim to give
+  initial feedback within **two business days**. If this does not happen, feel
+  free to leave a comment.
+
+  Please keep an eye on how this issue will be labeled, as labels give an
+  overview of priorities, assignments and additional actions requested by the
+  maintainers:
+
+    - "Priority" labels will show how urgent this is for the team.
+    - "Status" labels will show if this is ready to be worked on, blocked, or in progress.
+    - "Need" labels will indicate if additional input or analysis is required.
+
+  Finally, remember to use https://discuss.ipfs.io if you just need general
+  support.
+
+# Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome
+# Comment to be posted to on PRs from first time contributors in your repository
+newPRWelcomeComment: >
+  Thank you for submitting this PR!
+
+  A maintainer will be here shortly to review it.
+
+  We are super grateful, but we are also overloaded! Help us by making sure
+  that:
+
+    * The context for this PR is clear, with relevant discussion, decisions
+      and stakeholders linked/mentioned.
+
+    * Your contribution itself is clear (code comments, self-review for the
+      rest) and in its best form. Follow the [code contribution
+      guidelines](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md#code-contribution-guidelines)
+      if they apply.
+
+  Getting other community members to do a review would be great help too on
+  complex PRs (you can ask in the chats/forums). If you are unsure about
+  something, just leave us a comment.
+
+  Next steps:
+
+    * A maintainer will triage and assign priority to this PR, commenting on
+      any missing things and potentially assigning a reviewer for high
+      priority items.
+
+    * The PR gets reviews, discussed and approvals as needed.
+
+    * The PR is merged by maintainers when it has been approved and comments addressed.
+
+  We currently aim to provide initial feedback/triaging within **two business
+  days**. Please keep an eye on any labelling actions, as these will indicate
+  priorities and status of your contribution.
+
+  We are very grateful for your contribution!
+
+
+# Configuration for first-pr-merge - https://github.com/behaviorbot/first-pr-merge
+# Comment to be posted to on pull requests merged by a first time user
+# Currently disabled
+#firstPRMergeComment: ""
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
@@ -0,0 +1,11 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "10:00"
+  open-pull-requests-limit: 0
+  commit-message:
+    prefix: "deps"
+    prefix-development: "deps(dev)"
diff --git a/.github/workflows/examples.yml b/.github/workflows/examples.yml
@@ -0,0 +1,130 @@
+name: Examples
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+
+  # test-examples:
+  #   name: Test example ${{ matrix.example.name }}
+  #   needs: build
+  #   runs-on: ubuntu-latest
+  #   continue-on-error: true
+  #   strategy:
+  #     matrix:
+  #       example:
+  #         - name: ipfs browser add readable stream
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-add-readable-stream.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs browser angular
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-angular.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core,ipfs-core-types@$PWD/packages/ipfs-core-types
+  #         - name: ipfs browser browserify
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-browserify.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs browser react
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-create-react-app.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs browser exchange files
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-exchange-files.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core,ipfs@$PWD/packages/ipfs,ipfs-core-types@$PWD/packages/ipfs-core-types,ipfs-http-client@$PWD/packages/ipfs-http-client
+  #         - name: ipfs browser ipns publish
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-ipns-publish.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core,ipfs-http-client@$PWD/packages/ipfs-http-client
+  #         - name: ipfs browser mfs
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-mfs.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         # fails with No native build was found for platform=darwin arch=x64 runtime=node abi=93 uv=1 libc=glibc node=16.13.0 webpack=true
+  #         #- name: ipfs browser nextjs
+  #         #  repo: https://github.com/ipfs-examples/js-ipfs-browser-nextjs.git
+  #         #  deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs browser parceljs
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-parceljs.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs browser readable stream
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-readablestream.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs browser service worker
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-service-worker.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core,ipfs-message-port-client@$PWD/packages/ipfs-message-port-client,ipfs-message-port-protocol@$PWD/packages/ipfs-message-port-protocol,ipfs-message-port-server@$PWD/packages/ipfs-message-port-server
+  #         - name: ipfs browser sharing across tabs
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-sharing-node-across-tabs.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core,ipfs-message-port-client@$PWD/packages/ipfs-message-port-client,ipfs-message-port-server@$PWD/packages/ipfs-message-port-server
+  #         - name: ipfs browser video streaming
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-video-streaming.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs browser vue
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-vue.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs browser webpack
+  #           repo: https://github.com/ipfs-examples/js-ipfs-browser-webpack.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs circuit relaying
+  #           repo: https://github.com/ipfs-examples/js-ipfs-circuit-relaying.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core,ipfs-http-client@$PWD/packages/ipfs-http-client
+  #         - name: ipfs custom ipfs repo
+  #           repo: https://github.com/ipfs-examples/js-ipfs-custom-ipfs-repo.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs custom ipld formats
+  #           repo: https://github.com/ipfs-examples/js-ipfs-custom-ipld-formats.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core,ipfs-daemon@$PWD/packages/ipfs-daemon,ipfs-http-client@$PWD/packages/ipfs-http-client
+  #         - name: ipfs custom libp2p
+  #           repo: https://github.com/ipfs-examples/js-ipfs-custom-libp2p.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs-http-client browser pubsub
+  #           repo: https://github.com/ipfs-examples/js-ipfs-http-client-browser-pubsub.git
+  #           deps: ipfs-http-client@$PWD/packages/ipfs-http-client,ipfs@$PWD/packages/ipfs
+  #         - name: ipfs-http-client bundle webpack
+  #           repo: https://github.com/ipfs-examples/js-ipfs-http-client-bundle-webpack.git
+  #           deps: ipfs-http-client@$PWD/packages/ipfs-http-client,ipfs@$PWD/packages/ipfs
+  #         - name: ipfs-http-client name api
+  #           repo: https://github.com/ipfs-examples/js-ipfs-http-client-name-api.git
+  #           deps: ipfs-http-client@$PWD/packages/ipfs-http-client
+  #         - name: ipfs-http-client upload file
+  #           repo: https://github.com/ipfs-examples/js-ipfs-http-client-upload-file.git
+  #           deps: ipfs@$PWD/packages/ipfs,ipfs-http-client@$PWD/packages/ipfs-http-client
+  #         - name: ipfs 101
+  #           repo: https://github.com/ipfs-examples/js-ipfs-101.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs-client add files
+  #           repo: https://github.com/ipfs-examples/js-ipfs-ipfs-client-add-files.git
+  #           deps: ipfs@$PWD/packages/ipfs,ipfs-client@$PWD/packages/ipfs-client
+  #         - name: ipfs electron js
+  #           repo: https://github.com/ipfs-examples/js-ipfs-run-in-electron.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: ipfs running multiple nodes
+  #           repo: https://github.com/ipfs-examples/js-ipfs-running-multiple-nodes.git
+  #           deps: ipfs@$PWD/packages/ipfs
+  #         - name: ipfs traverse ipld graphs
+  #           repo: https://github.com/ipfs-examples/js-ipfs-traverse-ipld-graphs.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: types with typescript
+  #           repo: https://github.com/ipfs-examples/js-ipfs-types-use-ipfs-from-ts.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #         - name: types with typed js
+  #           repo: https://github.com/ipfs-examples/js-ipfs-types-use-ipfs-from-typed-js.git
+  #           deps: ipfs-core@$PWD/packages/ipfs-core
+  #   steps:
+  #     - uses: actions/checkout@v2
+  #     - uses: actions/setup-node@v2
+  #       with:
+  #         node-version: lts/*
+  #     - uses: ipfs/aegir/actions/cache-node-modules@master
+  #     - uses: GabrielBB/xvfb-action@v1
+  #       name: Run npm run test:external -- -- -- ${{ matrix.example.repo }} --deps ${{ matrix.example.deps }}
+  #       with:
+  #         run: npm run test:external -- -- -- ${{ matrix.example.repo }} --deps ${{ matrix.example.deps }}
diff --git a/.github/workflows/externals.yml b/.github/workflows/externals.yml
@@ -0,0 +1,51 @@
+name: Externals
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+
+  test-externals:
+    name: Test external ${{ matrix.external.name }}
+    needs: build
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        external:
+          - name: ipfs webui
+            repo: https://github.com/ipfs-shipyard/ipfs-webui.git
+            deps: ipfs@$PWD/packages/ipfs
+          - name: ipfs companion
+            repo: https://github.com/ipfs-shipyard/ipfs-companion.git
+            deps: ipfs@$PWD/packages/ipfs
+          - name: orbit-db-io
+            repo: https://github.com/orbitdb/orbit-db-io.git
+            deps: ipfs@$PWD/packages/ipfs
+          - name: ipfs-log
+            repo: https://github.com/orbitdb/ipfs-log.git
+            deps: ipfs@$PWD/packages/ipfs,orbit-db-io@next
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - uses: GabrielBB/xvfb-action@v1
+        name: Run npm run test:external -- -- -- ${{ matrix.external.repo }} --deps ${{ matrix.external.deps }} --branch ${{ matrix.external.branch }}
+        continue-on-error: true
+        with:
+          run: npm run test:external -- -- -- ${{ matrix.external.repo }} --deps ${{ matrix.external.deps }} --branch ${{ matrix.external.branch }}
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
@@ -0,0 +1,26 @@
+name: Close and mark stale issue
+
+on:
+  schedule:
+  - cron: '0 0 * * *'
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+    - uses: actions/stale@v3
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'Oops, seems like we needed more information for this issue, please comment with more details or this issue will be closed in 7 days.'
+        close-issue-message: 'This issue was closed because it is missing author input.'
+        stale-issue-label: 'kind/stale'
+        any-of-labels: 'need/author-input'
+        exempt-issue-labels: 'need/triage,need/community-input,need/maintainer-input,need/maintainers-input,need/analysis,status/blocked,status/in-progress,status/ready,status/deferred,status/inactive'
+        days-before-issue-stale: 6
+        days-before-issue-close: 7
+        enable-statistics: true
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -0,0 +1,268 @@
+name: Test
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+
+  check:
+    name: Check
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: |
+          npm run lint
+          npm run dep-check -- -- -- -p
+          npm run dep-check -- -- -- -- --unused
+
+  test-node:
+    name: Unit tests node ${{ matrix.node }} ${{ matrix.os }}
+    needs: build
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        node: [lts/*]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:node
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          flags: node
+
+  test-chrome:
+    name: Unit tests chrome
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:chrome
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          flags: chrome
+
+  test-chrome-webworker:
+    name: Unit tests chrome-webworker
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:chrome-webworker
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          flags: chrome-webworker
+
+  test-firefox:
+    name: Unit tests firefox
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:firefox
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          flags: firefox
+
+  test-firefox-webworker:
+    name: Unit tests firefox-webworker
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npx playwright install --with-deps
+      - run: npm run test:firefox-webworker
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          flags: firefox-webworker
+
+  test-electron-main:
+    name: Unit tests electron-main
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - uses: GabrielBB/xvfb-action@v1
+        with:
+          run: npm run test:electron-main
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          flags: electron-main
+
+  test-interop:
+    name: Interop tests ${{ matrix.project }} ${{ matrix.type }}
+    needs: build
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        type:
+          - node
+          - browser
+          #- electron-main
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:interop -- -- -- -t ${{ matrix.type }}
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          flags: interop-${{ matrix.type }}
+
+  test-interface:
+    name: Interface tests ${{ matrix.suite }} ${{ matrix.type }}
+    needs: build
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        type:
+          - node
+          - browser
+          #- electron-main
+        suite:
+          - test:interface:core
+          - test:interface:client
+          - test:interface:http-go
+          - test:interface:http-js
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run ${{ matrix.suite }} -- -- -t ${{ matrix.type }}
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          flags: interface-${{ matrix.type }}
+
+  test-interface-message-port-client:
+    name: Interface tests test:interface:message-port-client browser
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npx playwright install --with-deps
+      - run: npm run test:interface:message-port-client
+
+  release:
+    runs-on: ubuntu-latest
+    needs: [
+      test-node,
+      test-chrome,
+      test-chrome-webworker,
+      test-firefox,
+      test-firefox-webworker,
+      test-electron-main,
+      test-interop,
+      test-interface,
+      test-interface-message-port-client
+    ]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    steps:
+      - uses: GoogleCloudPlatform/release-please-action@v2
+        id: release
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          command: manifest
+          release-type: node
+          manifest-file: .release-please-manifest.json
+          config-file: .release-please.json
+          changelog-types: |
+            [
+              { "type": "feat", "section": "Features", "hidden": false },
+              { "type": "fix", "section": "Bug Fixes", "hidden": false },
+              { "type": "chore", "section": "Trivial Changes", "hidden": false },
+              { "type": "docs", "section": "Documentation", "hidden": false },
+              { "type": "deps", "section": "Dependencies", "hidden": false }
+            ]
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+          registry-url: 'https://registry.npmjs.org'
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - uses: ipfs/aegir/actions/docker-login@master
+        with:
+          docker-token: ${{ secrets.DOCKER_TOKEN }}
+          docker-username: ${{ secrets.DOCKER_USERNAME }}
+      - if: ${{ steps.release.outputs.releases_created }}
+        name: Run release version
+        run: |
+          git update-index --assume-unchanged packages/ipfs-core/src/version.js packages/ipfs-http-server/src/version.js packages/ipfs/src/package.js
+          npm run --if-present release
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - if: ${{ !steps.release.outputs.releases_created }}
+        name: Run release rc
+        run: |
+            git update-index --assume-unchanged packages/ipfs-core/src/version.js packages/ipfs-http-server/src/version.js packages/ipfs/src/package.js
+            npm run --if-present release:rc
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
diff --git a/.gitignore b/.gitignore
@@ -1,46 +1,37 @@
-**/node_modules/
-**/*.log
-test/repo-tests*
-**/bundle.js
 # Logs
 logs
 *.log
-# npm pack
-*.tgz
-**/tests_output
-
-coverage
-
-# Runtime data
-pids
-*.pid
-*.seed
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
+npm-debug.log*
+package-lock.json
+yarn.lock
+tsconfig-types.aegir.json
 
 # Coverage directory used by tools like istanbul
 coverage
+.coverage
 .nyc_output
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# node-waf configuration
-.lock-wscript
-
-build
+tests_output
+cache
+.cache
+.parcel-cache
 
 # Dependency directory
-# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
 node_modules
 
-lib
+# Build artefacts
 dist
-test/fixtures/go-ipfs-repo/LOCK
-test/fixtures/go-ipfs-repo/LOG
-test/fixtures/go-ipfs-repo/LOG.old
+build
+bundle.js
+tsconfig-types.aegir.json
+tsconfig-check.aegir.json
+.tsbuildinfo
 
-# while testing npm5
-package-lock.json
-yarn.lock
+# Deployment files
+.npmrc
+
+# Editor files
+.vscode
+
+# Operating system files
+.DS_Store
+types
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
@@ -0,0 +1 @@
+{"packages/interface-ipfs-core":"0.158.1","packages/ipfs":"0.66.1","packages/ipfs-cli":"0.16.1","packages/ipfs-client":"0.10.1","packages/ipfs-core":"0.18.1","packages/ipfs-core-config":"0.7.1","packages/ipfs-core-types":"0.14.1","packages/ipfs-core-utils":"0.18.1","packages/ipfs-daemon":"0.16.1","packages/ipfs-grpc-client":"0.13.1","packages/ipfs-grpc-protocol":"0.8.1","packages/ipfs-grpc-server":"0.12.1","packages/ipfs-http-client":"60.0.1","packages/ipfs-http-gateway":"0.13.1","packages/ipfs-http-response":"6.0.1","packages/ipfs-http-server":"0.15.1","packages/ipfs-message-port-client":"0.15.1","packages/ipfs-message-port-protocol":"0.15.1","packages/ipfs-message-port-server":"0.15.1"}
diff --git a/.release-please.json b/.release-please.json
@@ -0,0 +1,26 @@
+{
+  "plugins": ["node-workspace"],
+  "bump-minor-pre-major": true,
+  "group-pull-request-title-pattern": "chore: release ${component}",
+  "packages": {
+    "packages/interface-ipfs-core": {},
+    "packages/ipfs": {},
+    "packages/ipfs-cli": {},
+    "packages/ipfs-client": {},
+    "packages/ipfs-core": {},
+    "packages/ipfs-core-config": {},
+    "packages/ipfs-core-types": {},
+    "packages/ipfs-core-utils": {},
+    "packages/ipfs-daemon": {},
+    "packages/ipfs-grpc-client": {},
+    "packages/ipfs-grpc-protocol": {},
+    "packages/ipfs-grpc-server": {},
+    "packages/ipfs-http-client": {},
+    "packages/ipfs-http-gateway": {},
+    "packages/ipfs-http-response": {},
+    "packages/ipfs-http-server": {},
+    "packages/ipfs-message-port-client": {},
+    "packages/ipfs-message-port-protocol": {},
+    "packages/ipfs-message-port-server": {}
+  }
+}
diff --git a/.travis.yml b/.travis.yml
diff --git a/CHANGELOG.md b/CHANGELOG.md
diff --git a/COPYRIGHT b/COPYRIGHT
@@ -0,0 +1,5 @@
+This project is transitioning from an MIT-only license to a dual MIT/Apache-2.0 license.
+Unless otherwise noted, all code contributed prior to 2019-11-21 and not contributed by
+a user listed in [this signoff issue](https://github.com/ipfs/js-ipfs/issues/2624) is
+licensed under MIT-only. All new contributions (and past contributions since 2019-11-21)
+are licensed under a dual MIT/Apache-2.0 license.
diff --git a/Dockerfile b/Dockerfile
diff --git a/Dockerfile.latest b/Dockerfile.latest
@@ -0,0 +1,30 @@
+FROM node:16-alpine
+
+ENV IPFS_VERSION=latest
+ENV IPFS_MONITORING=1
+ENV IPFS_PATH=/root/.jsipfs
+ENV BUILD_DEPS='libnspr4 libnspr4-dev libnss3'
+
+RUN apk add --no-cache git python3 build-base
+
+# Hopefully remove when https://github.com/node-webrtc/node-webrtc/pull/694 is merged
+RUN npm install -g ipfs@"$IPFS_VERSION"
+
+# Make the image a bit smaller
+RUN npm cache clear --force
+RUN apk del build-base python3 git
+
+# Configure jsipfs
+RUN jsipfs init
+
+RUN jsipfs version
+
+# Allow connections from any host
+RUN sed -i.bak "s/127.0.0.1/0.0.0.0/g" $IPFS_PATH/config
+
+EXPOSE 4002
+EXPOSE 4003
+EXPOSE 5002
+EXPOSE 9090
+
+CMD jsipfs daemon
diff --git a/Dockerfile.next b/Dockerfile.next
@@ -0,0 +1,30 @@
+FROM node:16-alpine
+
+ENV IPFS_VERSION=next
+ENV IPFS_MONITORING=1
+ENV IPFS_PATH=/root/.jsipfs
+ENV BUILD_DEPS='libnspr4 libnspr4-dev libnss3'
+
+RUN apk add --no-cache git python3 build-base
+
+# Hopefully remove when https://github.com/node-webrtc/node-webrtc/pull/694 is merged
+RUN npm install -g ipfs@"$IPFS_VERSION"
+
+# Make the image a bit smaller
+RUN npm cache clear --force
+RUN apk del build-base python3 git
+
+# Configure jsipfs
+RUN jsipfs init
+
+RUN jsipfs version
+
+# Allow connections from any host
+RUN sed -i.bak "s/127.0.0.1/0.0.0.0/g" $IPFS_PATH/config
+
+EXPOSE 4002
+EXPOSE 4003
+EXPOSE 5002
+EXPOSE 9090
+
+CMD jsipfs daemon
diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
diff --git a/LICENSE b/LICENSE
@@ -1,21 +1,4 @@
-The MIT License (MIT)
+This project is dual licensed under MIT and Apache-2.0.
 
-Copyright (c) 2014 Juan Batiz-Benet
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+MIT: https://www.opensource.org/licenses/mit
+Apache-2.0: https://www.apache.org/licenses/license-2.0
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
@@ -0,0 +1,5 @@
+Licensed 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.
diff --git a/LICENSE-MIT b/LICENSE-MIT
@@ -0,0 +1,19 @@
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/README.md b/README.md
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
@@ -0,0 +1,36 @@
+# IPFS Architecture <!-- omit in toc -->
+
+## Table of Contents <!-- omit in toc -->
+
+- [Code Architecture and folder Structure](#code-architecture-and-folder-structure)
+  - [Source code](#source-code)
+
+![](./img/architecture.png)
+
+[Annotated version](https://user-images.githubusercontent.com/1211152/47606420-b6265780-da13-11e8-923b-b365a8534e0e.png)
+
+What does this image explain?
+
+- IPFS uses `ipfs-repo` which picks `fs` or `indexeddb` as its storage drivers, depending if it is running in Node.js or in the Browser.
+- The exchange protocol, `bitswap`, uses the Block Service which in turn uses the Repo, offering a get and put of blocks to the IPFS implementation.
+- The DAG API (previously Object) comes from the IPLD Resolver, it can support several IPLD Formats (i.e: dag-pb, dag-cbor, etc).
+- The Files API uses `ipfs-unixfs-engine` to import and export files to and from IPFS.
+- libp2p, the network stack of IPFS, uses libp2p to dial and listen for connections, to use the DHT, for discovery mechanisms, and more.
+
+## Code Architecture and folder Structure
+
+![](./img/overview.png)
+
+### Source code
+
+```Bash
+> tree src -L 2
+src                 # Main source code folder
+├── cli             # Implementation of the IPFS CLI
+│   └── ...
+├── http            # The HTTP-API implementation of IPFS as defined by HTTP API spec
+├── core            # IPFS implementation, the core (what gets loaded in browser)
+│   ├── components  # Each of IPFS subcomponent
+│   └── ...
+└── ...
+```
diff --git a/docs/BROWSERS.md b/docs/BROWSERS.md
@@ -0,0 +1,81 @@
+# Using JS IPFS in the Browser <!-- omit in toc -->
+
+## Table of Contents <!-- omit in toc -->
+
+- [Limitations of the Browser Context](#limitations-of-the-browser-context)
+- [Addressing Limitations](#addressing-limitations)
+- [Best Practices](#best-practices)
+- [Code Examples](#code-examples)
+
+JS IPFS is the implementation of IPFS protocol in JavaScript. It can run on any
+evergreen browser, inside a service or web worker, browser extensions, Electron, and in Node.js.
+
+**This document provides key information about running JS IPFS in the browser.
+Save time and get familiar with common caveats and limitations of the browser context.**
+
+## Limitations of the Browser Context
+
+- Transport options are currently limited to [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) and [WebRTC](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API).
+
+  This means JS IPFS running in the browser is limited to Web APIs available on a web page.
+  There is no access to raw TCP sockets nor low-level UDP, only WebSockets, and WebRTC.
+
+- Key [Web APIs](https://developer.mozilla.org/en-US/docs/Web/API) require or are restricted by [Secure Context](https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts) policies.
+
+  This means JS IPFS needs to run within Secure Context (HTTPS or localhost).
+  JS IPFS running on HTTPS website requires Secure WebSockets (TLS) and won't work with unencrypted ones.
+  [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) not being available at all.
+
+- JS IPFS comes with limited support for the [DHT](https://docs.ipfs.tech/concepts/dht/) in client mode which delegates content discovery requests to other DHT nodes.
+
+  However, it's worth noting that even though you'll get results from DHT queries, most nodes in the network are not dialable from browsers because they only support TCP and/or QUIC transports.
+
+  For now, the content discovery and connectivity to other peers are achieved with a mix of DHT client requests, rendezvous and relay servers, delegated peer/content routing, and preload servers.
+
+
+## Addressing Limitations
+
+We provide a few additional components useful for running JS IPFS in the browser:
+
+
+- [libp2p-webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star) - incorporates both a transport and a discovery service that is facilitated by the custom rendezvous server available in the repo
+  - Instructions on enabling `webrtc-star` in js-ipfs config can be found [here](https://github.com/ipfs/js-ipfs/blob/master/docs/FAQ.md#how-to-enable-webrtc-support-for-js-ipfs-in-the-browser).
+  - Make sure to [run your own rendezvous server](https://github.com/libp2p/js-libp2p-webrtc-star#rendezvous-server-aka-signalling-server).
+- [libp2p-webrtc-direct](https://github.com/libp2p/js-libp2p-webrtc-direct) - a WebRTC transport that doesn't require the set up a signaling server.
+  - Caveat: you can only establish Browser to Node.js and Node.js to Node.js connections.
+
+**Note:** those are semi-centralized solutions. We are working towards replacing `*-star` with ambient relays and [libp2p-rendezvous](https://github.com/libp2p/js-libp2p-rendezvous). Details and progress can be found [here](https://github.com/libp2p/js-libp2p/issues/385).
+
+You can find detailed information about running js-ipfs [here](https://github.com/ipfs/js-ipfs#table-of-contents).
+
+## Best Practices
+
+- Configure nodes for using self-hosted `*-star` signalling and transport service. When in doubt, use WebSockets ones.
+- Run your own instance of `*-star` signalling service.
+  The default ones are under high load and should be used only for tests and development.
+- Make sure content added to js-ipfs running in the browser is persisted/cached somewhere on a regular long-running IPFS daemon, e.g. [kubo](https://github.com/ipfs/kubo/)
+  - Manually `pin` or preload CIDs of interest with `refs -r` beforehand.
+  - Preload content on the fly using [preload](https://github.com/ipfs/js-ipfs/blob/master/docs/MODULE.md#optionspreload) feature and/or
+    configure [delegated routing](https://github.com/ipfs/js-ipfs/blob/master/docs/DELEGATE_ROUTERS.md).
+    - Avoid public instances in production environments. Make sure preload and delegate nodes used in config are self-hosted and under your control (expose a subset of [kubo](https://github.com/ipfs/kubo/) (formerly go-ipfs) APIs via reverse proxy such as Nginx).
+- If your main goal is to provide content and files to the IPFS network from a browser and you would like to avoid running infrastructure, consider using a pinning service like [Web3.storage](https://web3.storage/).
+
+## Code Examples
+
+Prebuilt bundles are available, using JS IPFS in the browser is as simple as:
+
+```js
+<script src="https://cdn.jsdelivr.net/npm/ipfs/dist/index.min.js"></script>
+<script>
+document.addEventListener('DOMContentLoaded', async () => {
+  const node = await Ipfs.create()
+  const results = await node.add('=^.^= meow meow')
+  const cid = results[0].hash
+  console.log('CID created via ipfs.add:', cid)
+  const data = await node.cat(cid)
+  console.log('Data read back via ipfs.cat:', new TextDecoder().decode(data))
+})
+</script>
+```
+
+More advanced examples and tutorials can be found in the [examples](https://github.com/ipfs-examples)
diff --git a/docs/CLI.md b/docs/CLI.md
@@ -0,0 +1,39 @@
+# IPFS CLI <!-- omit in toc -->
+
+## Table of contents <!-- omit in toc -->
+
+- [Overview](#overview)
+- [Configuration](#configuration)
+
+## Overview
+
+In order to use js-ipfs as a CLI, you must install it with the `global` flag. Run the following (even if you have ipfs installed locally):
+
+```bash
+npm install ipfs --global
+```
+
+The CLI is available by using the command `jsipfs` in your terminal. This is aliased, instead of using `ipfs`, to make sure it does not conflict with the [Go implementation](https://github.com/ipfs/go-ipfs).
+
+Once installed, please follow the [Getting Started Guide](https://docs.ipfs.io/introduction/usage/) to learn how to initialize your node and run the daemon.
+
+```sh
+# Install js-ipfs globally
+> jsipfs --help
+Commands:
+  bitswap               A set of commands to manipulate the bitswap agent.
+  block                 Manipulate raw IPFS blocks.
+  bootstrap             Show or edit the list of bootstrap peers.
+  commands              List all available commands
+  config <key> [value]  Get and set IPFS config values
+  daemon                Start a long-running daemon process
+# ...
+```
+
+## Configuration
+
+`js-ipfs` uses some different default config values, so that they don't clash directly with a go-ipfs node running in the same machine. These are:
+
+- default repo location: `~/.jsipfs` (can be changed with env variable `IPFS_PATH`)
+- default swarm port: `4002`
+- default API port: `5002`
diff --git a/docs/CONFIG.md b/docs/CONFIG.md
@@ -0,0 +1,352 @@
+# The js-ipfs config file <!-- omit in toc -->
+
+The js-ipfs config file is a JSON document located in the root directory of the js-ipfs repository.
+
+## Table of Contents <!-- omit in toc -->
+
+- [Profiles](#profiles)
+- [`Addresses`](#addresses)
+  - [`API`](#api)
+  - [`RPC`](#rpc)
+  - [`Delegates`](#delegates)
+  - [`Gateway`](#gateway)
+  - [`Swarm`](#swarm)
+  - [`Announce`](#announce)
+- [`Bootstrap`](#bootstrap)
+- [`Datastore`](#datastore)
+  - [`Spec`](#spec)
+- [`Discovery`](#discovery)
+  - [`MDNS`](#mdns)
+  - [`webRTCStar`](#webrtcstar)
+- [`Identity`](#identity)
+  - [`PeerID`](#peerid)
+  - [`PrivKey`](#privkey)
+- [`Keychain`](#keychain)
+- [`Pubsub`](#pubsub)
+  - [`Router`](#router)
+  - [`Enabled`](#enabled)
+- [`Swarm`](#swarm-1)
+  - [`ConnMgr`](#connmgr)
+  - [`DisableNatPortMap`](#disablenatportmap)
+  - [Example](#example)
+- [`API`](#api-1)
+  - [`HTTPHeaders`](#httpheaders)
+    - [`Access-Control-Allow-Origin`](#access-control-allow-origin)
+      - [Example](#example-1)
+    - [`Access-Control-Allow-Credentials`](#access-control-allow-credentials)
+      - [Example](#example-2)
+
+## Profiles
+
+Configuration profiles allow to tweak configuration quickly. Profiles can be
+applied with `--profile` flag to `ipfs init` or with the `ipfs config profile
+apply` command. When a profile is applied a backup of the configuration file
+will be created in `$IPFS_PATH`.
+
+Available profiles:
+
+- `server`
+
+  Recommended for nodes with public IPv4 address (servers, VPSes, etc.),
+  disables host and content discovery in local networks.
+
+- `local-discovery`
+
+  Sets default values to fields affected by `server` profile, enables
+  discovery in local networks.
+
+- `test`
+
+  Reduces external interference, useful for running ipfs in test environments.
+  Note that with these settings node won't be able to talk to the rest of the
+  network without manual bootstrap.
+
+- `default-networking`
+
+  Restores default network settings. Inverse profile of the `test` profile.
+
+- `lowpower`
+
+  Reduces daemon overhead on the system. May affect node functionality,
+  performance of content discovery and data fetching may be degraded.
+
+- `default-power`
+
+  Inverse of "lowpower" profile.
+
+## `Addresses`
+
+Contains information about various listener addresses to be used by this node.
+
+### `API`
+
+The IPFS daemon exposes an HTTP API that allows to control the node and run the same commands as you can do from the command line. It is defined on the [HTTP API Spec](https://docs.ipfs.io/reference/api/http).
+
+[Multiaddr](https://github.com/multiformats/multiaddr/) or array of [Multiaddr](https://github.com/multiformats/multiaddr/) describing the address(es) to serve the HTTP API on.
+
+Default: `/ip4/127.0.0.1/tcp/5002`
+
+### `RPC`
+
+js-IPFS has a gRPC-over-websockets server that allows it to do things that you cannot do over HTTP like bi-directional streaming.  It implements the same API as the [HTTP API Spec](https://docs.ipfs.io/reference/api/http) and can be accessed using the [ipfs-client](https://www.npmjs.com/package/ipfs-client) module.
+
+Configure the address it listens on using this config key.
+
+Default: `/ip4/127.0.0.1/tcp/5003`
+
+### `Delegates`
+
+Delegate peers are used to find peers and retrieve content from the network on your behalf.
+
+Array of [Multiaddr](https://github.com/multiformats/multiaddr/) describing which addresses to use as delegate nodes.
+
+Default: `[]`
+
+### `Gateway`
+
+A gateway is exposed by the IPFS daemon, which allows an easy way to access content from IPFS, using an IPFS path.
+
+[Multiaddr](https://github.com/multiformats/multiaddr/) or array of [Multiaddr](https://github.com/multiformats/multiaddr/) describing the address(es) to serve the gateway on.
+
+Default: `/ip4/127.0.0.1/tcp/9090`
+
+### `Swarm`
+
+Array of [Multiaddr](https://github.com/multiformats/multiaddr/) describing which addresses to listen on for p2p swarm connections.
+
+Default:
+```json
+[
+  "/ip4/0.0.0.0/tcp/4002",
+  "/ip4/127.0.0.1/tcp/4003/ws"
+]
+```
+
+### `Announce`
+
+Array of [Multiaddr](https://github.com/multiformats/multiaddr/) describing which addresses to [announce](https://github.com/libp2p/js-libp2p/tree/master/src/address-manager#announce-addresses) over the network.
+
+Default:
+```json
+[]
+```
+
+## `Bootstrap`
+
+Bootstrap is an array of [Multiaddr](https://github.com/multiformats/multiaddr/) of trusted nodes to connect to in order to
+initiate a connection to the network.
+
+## `Datastore`
+
+Contains information related to the construction and operation of the on-disk storage system.
+
+### `Spec`
+
+Spec defines the structure of the IPFS datastore. It is a composable structure, where each datastore is represented by a JSON object. Datastores can wrap other datastores to provide extra functionality (e.g. metrics, logging, or caching).
+
+This can be changed manually, however, if you make any changes that require a different on-disk structure, you will need to run the [ipfs-ds-convert tool](https://github.com/ipfs/ipfs-ds-convert) to migrate data into the new structures.
+
+Default:
+```json
+{
+  "mounts": [
+    {
+      "child": {
+        "path": "blocks",
+        "shardFunc": "/repo/flatfs/shard/v1/next-to-last/2",
+        "sync": true,
+        "type": "flatfs"
+      },
+      "mountpoint": "/blocks",
+      "prefix": "flatfs.datastore",
+      "type": "measure"
+    },
+    {
+      "child": {
+        "compression": "none",
+        "path": "datastore",
+        "type": "levelds"
+      },
+      "mountpoint": "/",
+      "prefix": "leveldb.datastore",
+      "type": "measure"
+    }
+  ],
+  "type": "mount"
+}
+```
+
+## `Discovery`
+
+Contains options for configuring IPFS node discovery mechanisms.
+
+### `MDNS`
+
+Multicast DNS is a discovery protocol that is able to find other peers on the local network.
+
+Options for Multicast DNS peer discovery:
+
+- `Enabled`
+
+    A boolean value for whether or not MDNS should be active.
+
+    Default: `true`
+
+-  `Interval`
+
+	  A number of seconds to wait between discovery checks.
+
+    Default: `10`
+
+### `webRTCStar`
+
+WebRTCStar is a discovery mechanism provided by a signalling-star that allows peer-to-peer communications in the browser.
+
+Options for webRTCstar peer discovery:
+
+- `Enabled`
+
+    A boolean value for whether or not webRTCStar should be active.
+
+    Default: `true`
+
+## `Identity`
+
+### `PeerID`
+
+The unique PKI identity label for this configs peer. Set on init and never read, its merely here for convenience. IPFS will always generate the peerID from its keypair at runtime.
+
+### `PrivKey`
+
+The base64 encoded protobuf describing (and containing) the nodes private key.
+
+## `Keychain`
+
+We can customize the key management and cryptographically protected messages by changing the Keychain options. Those options are used for generating the derived encryption key (`DEK`). The `DEK` object, along with the passPhrase, is the input to a PBKDF2 function.
+
+Default:
+```json
+{
+  "dek": {
+    "keyLength": 512/8,
+    "iterationCount": 1000,
+    "salt": "at least 16 characters long",
+    "hash": "sha2-512"
+  }
+}
+```
+
+You can check the [parameter choice for pbkdf2](https://cryptosense.com/parameter-choice-for-pbkdf2/) for more information.
+
+## `Pubsub`
+
+Options for configuring the pubsub subsystem. It is important pointing out that this is not supported in the browser. If you want to configure a different pubsub router in the browser you must configure `libp2p.modules.pubsub` options instead.
+
+### `Router`
+
+A string value for specifying which pubsub routing protocol to use. You can either use `gossipsub` in order to use the [ChainSafe/gossipsub-js](https://github.com/ChainSafe/gossipsub-js) implementation, or `floodsub` to use the [libp2p/js-libp2p-floodsub](https://github.com/libp2p/js-libp2p-floodsub) implementation. You can read more about these implementations on the [libp2p/specs/pubsub](https://github.com/libp2p/specs/tree/master/pubsub) document.
+
+Default: `gossipsub`
+
+### `Enabled`
+
+A boolean value for wether or not pubsub router should be active.
+
+Default: `true`
+
+## `Swarm`
+
+Options for configuring the swarm.
+
+### `ConnMgr`
+
+The connection manager determines which and how many connections to keep and can be configured to keep.
+
+- `LowWater`
+
+    The minimum number of connections to maintain.
+
+    Default: `200` (both browser and node.js)
+
+- `HighWater`
+
+    The number of connections that, when exceeded, will trigger a connection GC operation.
+
+    Default: `500` (both browser and node.js)
+
+The "basic" connection manager tries to keep between `LowWater` and `HighWater` connections. It works by:
+
+1. Keeping all connections until `HighWater` connections is reached.
+2. Once `HighWater` is reached, it closes connections until `LowWater` is reached.
+
+### `DisableNatPortMap`
+
+By default when running under nodejs, libp2p will try to use [UPnP](https://en.wikipedia.org/wiki/Universal_Plug_and_Play) to open a random high port on your router for any TCP connections you have configured.
+
+Set `DisableNatPortMap` to `true` to disable this behaviour.
+
+### Example
+
+```json
+{
+  "Swarm": {
+    "ConnMgr": {
+      "LowWater": 100,
+      "HighWater": 200,
+    }
+  },
+  "DisableNatPortMap": false
+}
+```
+
+## `API`
+
+Settings applied to the HTTP RPC API server
+
+### `HTTPHeaders`
+
+HTTP header settings used by the HTTP RPC API server
+
+#### `Access-Control-Allow-Origin`
+
+The RPC API endpoints running on your local node are protected by the [Cross-Origin Resource Sharing](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) mechanism.
+
+When a request is made that sends an `Origin` header, that Origin must be present in the allowed origins configured for the node, otherwise the browser will disallow that request to proceed, unless `mode: 'no-cors'` is set on the request, in which case the response will be opaque.
+
+To allow requests from web browsers, configure the `API.HTTPHeaders.Access-Control-Allow-Origin` setting.  This is an array of URL strings with safelisted Origins.
+
+##### Example
+
+If you are running a webapp locally that you access via the URL `http://127.0.0.1:3000`, you must add it to the list of allowed origins in order to make API requests from that webapp in the browser:
+
+```json
+{
+  "API": {
+    "HTTPHeaders": {
+      "Access-Control-Allow-Origin": [
+        "http://127.0.0.1:3000"
+      ]
+    }
+  }
+}
+```
+
+Note that the origin must match exactly so `'http://127.0.0.1:3000'` is treated differently to `'http://127.0.0.1:3000/'`
+
+#### `Access-Control-Allow-Credentials`
+
+The [Access-Control-Allow-Credentials](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Credentials) header allows client-side JavaScript running in the browser to send and receive credentials with requests - cookies, auth headers or TLS certificates.
+
+For most applications this will not be necessary but if you require this to be set, see the example below for how to configure it.
+
+##### Example
+
+```json
+{
+  "API": {
+    "HTTPHeaders": {
+      "Access-Control-Allow-Credentials": true
+    }
+  }
+}
+```
diff --git a/docs/CORS.md b/docs/CORS.md
@@ -0,0 +1,23 @@
+# CORS <!-- omit in toc -->
+
+## Table of Contents <!-- omit in toc -->
+
+- [Overview](#overview)
+- [Configure CORS headers](#configure-cors-headers)
+
+## Overview
+
+Cross-origin Resource Sharing is a browser security mechanism that prevents unauthorized scripts from accessing resources from different domains.
+
+By default the HTTP RPC API of js-IPFS will cause any request sent from a CORS-respecting browser to fail.
+
+## Configure CORS headers
+
+You can configure your node to allow requests from other domains to proceed by setting the appropriate headers in the node config:
+
+```console
+$ jsipfs config --json API.HTTPHeaders.Access-Control-Allow-Origin  '["http://example.com"]'
+$ jsipfs config --json API.HTTPHeaders.Access-Control-Allow-Methods '["PUT", "POST", "GET"]'
+```
+
+Restart the daemon for the settings to take effect.
diff --git a/docs/DAEMON.md b/docs/DAEMON.md
@@ -0,0 +1,35 @@
+
+# Running IPFS as a daemon <!-- omit in toc -->
+
+> How to run a long-lived IPFS process
+
+## Table of contents <!-- omit in toc -->
+
+- [CLI](#cli)
+- [Programmatic](#programmatic)
+
+## CLI
+
+To start a daemon on the CLI, use the `daemon` command:
+
+```console
+jsipfs daemon
+```
+
+The IPFS Daemon exposes the API defined in the [HTTP API spec](https://docs.ipfs.io/reference/api/http/). You can use any of the IPFS HTTP-API client libraries with it, such as: [ipfs-http-client](https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-http-client).
+
+## Programmatic
+
+If you want a programmatic way to spawn a IPFS Daemon using JavaScript, check out the [ipfsd-ctl](https://github.com/ipfs/js-ipfsd-ctl) module.
+
+```javascript
+import { createFactory } from 'ipfsd-ctl'
+const factory = createFactory({
+  type: 'proc' // or 'js' to run in a separate process
+})
+
+const node = await factory.create()
+
+// print the node ide
+console.info(await node.id())
+```
diff --git a/docs/DELEGATE_ROUTERS.md b/docs/DELEGATE_ROUTERS.md
@@ -0,0 +1,30 @@
+# Configuring Delegate Routers <!-- omit in toc -->
+
+- [What is it?](#what-is-it)
+- [How do I do it?](#how-do-i-do-it)
+
+## What is it?
+
+Delegate routers perform tasks on behalf of nodes that may be missing functionality, so for example they may search the DHT for peers or content providers on behalf of IPFS implementations that do not have a DHT.
+
+The delegate node is started and the client of the delegate calls API methods using the IPFS HTTP API client.
+
+## How do I do it?
+
+If you need to support Delegated Content and/or Peer Routing, you can enable it by specifying the multiaddrs of your delegate nodes in the config via `options.config.Addresses.Delegates`. If you need to run a delegate router we encourage you to run your own, with go-ipfs. You can see instructions for doing so in the [delegated routing example](https://github.com/libp2p/js-libp2p/tree/master/examples/delegated-routing).
+
+If you are not able to run your own delegate router nodes, we currently have two nodes that support delegated routing. **Important**: As many people may be leveraging these nodes, performance may be affected, which is why we recommend running your own nodes in production.
+
+Available delegate multiaddrs are:
+
+- `/dns4/node0.delegate.ipfs.io/tcp/443/https`
+- `/dns4/node1.delegate.ipfs.io/tcp/443/https`
+- `/dns4/node2.delegate.ipfs.io/tcp/443/https`
+- `/dns4/node3.delegate.ipfs.io/tcp/443/https`
+
+**Note**: If more than 1 delegate multiaddr is specified, the actual delegate will be randomly selected on startup.
+
+**Note**: If you wish to use delegated routing and are creating your node _programmatically_ in Node.js or the browser you must `npm install libp2p-delegated-content-routing` and/or `npm install libp2p-delegated-peer-routing` and provide configured instances of them in [`options.libp2p`](./MODULE.md#optionslibp2p). See the module repos for further instructions:
+
+- https://github.com/libp2p/js-libp2p-delegated-content-routing
+- https://github.com/libp2p/js-libp2p-delegated-peer-routing
diff --git a/docs/DEVELOPMENT.md b/docs/DEVELOPMENT.md
@@ -0,0 +1,128 @@
+# Development <!-- omit in toc -->
+
+> Getting started with development on IPFS
+
+- [Install npm@7](#install-npm7)
+- [Clone and install dependencies](#clone-and-install-dependencies)
+- [Run tests](#run-tests)
+- [Lint](#lint)
+- [Build types and minified browser bundles](#build-types-and-minified-browser-bundles)
+- [Publishing new versions](#publishing-new-versions)
+- [Using prerelease versions](#using-prerelease-versions)
+- [Testing strategy](#testing-strategy)
+  - [CLI](#cli)
+  - [HTTP API](#http-api)
+  - [Core](#core)
+  - [Non-Core](#non-core)
+
+## Install npm@7
+
+This project uses a [workspace](https://docs.npmjs.com/cli/v7/using-npm/workspaces) structure so requires npm@7 or above.  If you are running node 15 or later you already have it, if not run:
+
+```sh
+$ npm install -g npm@latest
+```
+
+## Clone and install dependencies
+
+```sh
+> git clone https://github.com/ipfs/js-ipfs.git
+> cd js-ipfs
+> npm install
+```
+
+This will install the dependencies of the various packages, deduping and hoisting dependencies into the root folder.
+
+If later you add new dependencies to submodules or just wish to remove all the `node_modules`/`dist` folders and start again, run `npm run reset && npm install` from the root.
+
+See the scripts section of the root [`package.json`](../package.json) for more commands.
+
+## Run tests
+
+```sh
+# run all the unit tests
+> npm test
+
+# run individual tests (findprovs)
+> npm run test -- --grep findprovs
+
+# run just IPFS tests in Node.js
+> npm run test -- -- -- -t node
+
+# run just IPFS tests in a headless browser
+> npm run test -- -- -- -t browser
+
+# run the interface tests against ipfs-core
+> npm run test:interface:core
+
+# run the interface tests over HTTP against js-ipfs
+> npm run test:interface:http-js
+
+# run the interface tests over HTTP against go-ipfs from a browser
+> npm run test:interface:http-go -- -- -- -t browser
+
+# run the interop tests against js-ipfs and go-ipfs on the Electron main process
+> npm run test:interop -- -- -- -t electron-main
+```
+
+More granular test suites can be run from each submodule.
+
+Please see the `package.json` in each submodule for available commands.
+
+## Lint
+
+Please run the linter before submitting a PR, the build will not pass if it fails:
+
+```sh
+> npm run lint
+```
+
+## Build types and minified browser bundles
+
+```sh
+> npm run build
+```
+
+## Publishing new versions
+
+1. Ensure you have a `GH_TOKEN` env var containing a GitHub [Personal Access Token](https://github.com/settings/tokens) with `public_repo` permissions
+2. You'll also need a valid [Docker Hub](https://hub.docker.com) login with sufficient permissions to publish new Docker images to the [ipfs/js-ipfs](https://hub.docker.com/repository/docker/ipfs/js-ipfs) repository
+3. From the root of this repo run `npm run release` and follow the on screen prompts.  It will use [conventional commits](https://www.conventionalcommits.org) to work out the new package version
+
+## Using prerelease versions
+
+Any changed packages from each successful build of master are published to npm as canary builds under the npm tag `next`.
+
+## Testing strategy
+
+This project has a number of components that have their own tests, then some components that share interface tests.
+
+When adding new features you may need to add tests to one or more of the test suites described below.
+
+### CLI
+
+Tests live in [/packages/ipfs/test/cli](https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs/test/cli).
+
+All interactions with IPFS core are stubbed so we just ensure that the correct arguments are passed in
+
+### HTTP API
+
+Tests live in [/packages/ipfs/test/http-api](https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs/test/http-api) and are similar to the CLI tests in that we stub out core interactions and inject requests with [shot](https://www.npmjs.com/package/@hapi/shot).
+
+### Core
+
+Anything non-implementation specific should be considered part of the 'Core API'.  For example node setup code is not Core, but anything that does useful work, e.g. network/repo/etc interactions would be Core.
+
+All Core APIs should be documented in [/docs/core-api](https://github.com/ipfs/js-ipfs/tree/master/docs/core-api).
+
+All Core APIs should have comprehensive tests in [/packages/interface-ipfs-core](https://github.com/ipfs/js-ipfs/tree/master/packages/interface-ipfs-core).
+
+`interface-ipfs-core` should ensure API compatibility across implementations. Tests are run:
+
+1. Against [/packages/ipfs/src/core](https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs/src/core) directly
+1. Against [/packages/ipfs/src/http](https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs/src/http) over HTTP via `ipfs-http-client`
+1. Against `go-ipfs` over HTTP via `ipfs-http-client`
+
+### Non-Core
+
+Any non-core API functionality should have tests in the `tests` directory of the module in question, for example: [/packages/ipfs-http-api/tests](https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-http-client/test) and [/packages/ipfs/tests](https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs/test) for `ipfs-http-client` and `ipfs` respectively.
diff --git a/docs/DOCKER.md b/docs/DOCKER.md
@@ -0,0 +1,32 @@
+
+# Running js-ipfs with Docker
+
+We have automatic Docker builds setup with Docker Hub: https://hub.docker.com/r/ipfs/js-ipfs/
+
+All branches in the Github repository maps to a tag in Docker Hub, except `master` Git branch which is mapped to `latest` Docker tag.
+
+You can run js-ipfs like this:
+
+```
+$ docker run -it -p 4002:4002 -p 4003:4003 -p 5002:5002 -p 9090:9090 ipfs/js-ipfs:latest
+
+initializing ipfs node at /root/.jsipfs
+generating 2048-bit RSA keypair...done
+peer identity: Qmbd5jx8YF1QLhvwfLbCTWXGyZLyEJHrPbtbpRESvYs4FS
+to get started, enter:
+
+         jsipfs files cat /ipfs/QmfGBRT6BbWJd7yUc2uYdaUZJBbnEFvTqehPFoSMQ6wgdr/readme
+
+Initializing daemon...
+Using wrtc for webrtc support
+Swarm listening on /ip4/127.0.0.1/tcp/4003/ws/ipfs/Qmbd5jx8YF1QLhvwfLbCTWXGyZLyEJHrPbtbpRESvYs4FS
+Swarm listening on /ip4/172.17.0.2/tcp/4003/ws/ipfs/Qmbd5jx8YF1QLhvwfLbCTWXGyZLyEJHrPbtbpRESvYs4FS
+Swarm listening on /ip4/127.0.0.1/tcp/4002/ipfs/Qmbd5jx8YF1QLhvwfLbCTWXGyZLyEJHrPbtbpRESvYs4FS
+Swarm listening on /ip4/172.17.0.2/tcp/4002/ipfs/Qmbd5jx8YF1QLhvwfLbCTWXGyZLyEJHrPbtbpRESvYs4FS
+API is listening on: /ip4/0.0.0.0/tcp/5002
+Gateway (readonly) is listening on: /ip4/0.0.0.0/tcp/9090
+Daemon is ready
+
+$ curl --silent localhost:5002/api/v0/id | jq .ID
+"Qmbd5jx8YF1QLhvwfLbCTWXGyZLyEJHrPbtbpRESvYs4FS"
+```
diff --git a/docs/EARLY_TESTERS.md b/docs/EARLY_TESTERS.md
@@ -1,4 +1,9 @@
-# Early Testers Programme
+# Early Testers Programme <!-- omit in toc -->
+
+- [What is it?](#what-is-it)
+- [What are the expectations?](#what-are-the-expectations)
+- [Who has signed up?](#who-has-signed-up)
+- [How to sign up?](#how-to-sign-up)
 
 ## What is it?
 
@@ -26,6 +31,7 @@ We will ask early testers to participate at two points in the process:
 - [orbit-db](https://github.com/orbitdb/orbit-db) - Peer-to-Peer Databases for the Decentralized Web
 - [ipfs-log](https://github.com/orbitdb/ipfs-log) - Append-only log CRDT on IPFS
 - [Sidetree DID Protocol](https://github.com/decentralized-identity/sidetree) - Decentralized Identifier Layer-2 network protocol
+- [Constellation](https://julienmalard.github.io/constellation/) - Distributed scientific databases for citizen science and more
 
 ## How to sign up?
 

diff --git a/docs/FAQ.md b/docs/FAQ.md
@@ -0,0 +1,177 @@
+# FAQ <!-- omit in toc -->
+
+## Table of Contents <!-- omit in toc -->
+
+- [Why isn't there DHT support in js-IPFS?](#why-isnt-there-dht-support-in-js-ipfs)
+  - [Node.js](#nodejs)
+  - [Browser](#browser)
+- [How to enable WebRTC support for js-ipfs in the Browser](#how-to-enable-webrtc-support-for-js-ipfs-in-the-browser)
+- [Is there WebRTC support for js-ipfs with Node.js?](#is-there-webrtc-support-for-js-ipfs-with-nodejs)
+- [How can I configure an IPFS node to use a custom `signaling endpoint` for my WebRTC transport?](#how-can-i-configure-an-ipfs-node-to-use-a-custom-signaling-endpoint-for-my-webrtc-transport)
+- [I see some slowness when hopping between tabs Chrome with IPFS nodes, is there a reason why?](#i-see-some-slowness-when-hopping-between-tabs-chrome-with-ipfs-nodes-is-there-a-reason-why)
+- [Can I use IPFS in my Electron App?](#can-i-use-ipfs-in-my-electron-app)
+- [What are all these `refs?Qmfoo` HTTP errors I keep seeing in the console?](#what-are-all-these-refsqmfoo-http-errors-i-keep-seeing-in-the-console)
+- [Have more questions?](#have-more-questions)
+
+## Why isn't there DHT support in js-IPFS?
+
+There is DHT support for js-IPFS in the form of [libp2p/js-libp2p-kad-dht](https://github.com/libp2p/js-libp2p-kad-dht) but it is not finished yet, and may not be the right solution to the problem.
+
+### Node.js
+
+To enable DHT support, before starting your daemon run:
+
+```console
+$ jsipfs config Routing.Type dht
+```
+
+The possible values for `Routing.Type` are:
+
+ -  `'none'` the default, this means the DHT is turned off any you must manually dial other nodes
+ -  `'dht'` start the node in DHT client mode, if it is discovered to be publicly dialable it will automatically switch to server mode
+ -  `'dhtclient'` A DHT client is able to make DHT queries but will not respond to any
+ -  `'dhtserver'` A DHT server can make and respond to DHT queries.  Please only choose this option if your node is dialable from the open Internet.
+
+At the time of writing, only DHT client mode is supported and will be selected if `Routing.Type` is not `'none'`.
+
+### Browser
+
+In the browser there are many constraints that mean the environment does not typically make for good DHT participants - the number of connections required is high, people do not tend to stay on a page for long enough to make or answer DHT queries, and even if they did, most nodes on the network talk TCP - the browser can neither open TCP ports on remote hosts nor accept TCP connections.
+
+A better approach may be to set up [Delegate Routing](./DELEGATE_ROUTERS.md) to use remote go-IPFS to make queries on the browsers' behalf as these do not have the same constraints.
+
+Of course, there's no reason why js on the server should not be a fully fledged DHT participant, please help out on the [libp2p/js-libp2p-kad-dht](https://github.com/libp2p/js-libp2p-kad-dht) repo to make this a reality!
+
+## How to enable WebRTC support for js-ipfs in the Browser
+
+To add a WebRTC transport to your js-ipfs node, you must add a WebRTC multiaddr. To do that, simple override the config.Addresses.Swarm array which contains all the multiaddrs which the IPFS node will use. See below:
+
+```JavaScript
+const node = await IPFS.create({
+  config: {
+    Addresses: {
+      Swarm: [
+        '/dns4/wrtc-star1.par.dwebops.pub/tcp/443/wss/p2p-webrtc-star',
+        '/dns4/wrtc-star2.sjc.dwebops.pub/tcp/443/wss/p2p-webrtc-star'
+      ]
+    }
+  }
+})
+
+// your instance with WebRTC is ready
+```
+
+**Important:** This transport usage is kind of unstable and several users have experienced crashes. Track development of a solution at https://github.com/ipfs/js-ipfs/issues/1088.
+
+## Is there WebRTC support for js-ipfs with Node.js?
+
+Yes, however, bear in mind that there isn't a 100% stable solution to use WebRTC in Node.js, use it at your own risk. The most tested options are:
+
+- [wrtc](https://npmjs.org/wrtc) - Follow the install instructions.
+- [electron-webrtc](https://npmjs.org/electron-webrtc)
+
+To add WebRTC support in a IPFS node instance, do:
+
+```JavaScript
+import wrtc from 'wrtc' // or 'electron-webrtc'
+import WebRTCStar from '@libp2p/webrtc-star'
+
+const node = await IPFS.create({
+  repo: 'your-repo-path',
+  config: {
+    Addresses: {
+      Swarm: [
+        "/ip4/0.0.0.0/tcp/4002",
+        "/ip4/127.0.0.1/tcp/4003/ws",
+        "/dns4/wrtc-star1.par.dwebops.pub/tcp/443/wss/p2p-webrtc-star",
+        "/dns4/wrtc-star2.sjc.dwebops.pub/tcp/443/wss/p2p-webrtc-star"
+      ]
+    }
+  },
+  libp2p: {
+    modules: {
+      transport: [WebRTCStar]
+    },
+    config: {
+      peerDiscovery: {
+        webRTCStar: { // <- note the lower-case w - see https://github.com/libp2p/js-libp2p/issues/576
+          enabled: true
+        }
+      },
+      transport: {
+        WebRTCStar: { // <- note the upper-case w- see https://github.com/libp2p/js-libp2p/issues/576
+          wrtc
+        }
+      }
+    }
+  }
+})
+
+// your instance with WebRTC is ready
+```
+
+To add WebRTC support to the IPFS daemon, you only need to install one of the WebRTC modules globally:
+
+```bash
+npm install wrtc --global
+# or
+npm install electron-webrtc --global
+```
+
+Then, update your IPFS Daemon config to include the multiaddr for this new transport on the `Addresses.Swarm` array. Add: `"/dns4/wrtc-star.discovery.libp2p.io/wss/p2p-webrtc-star"`
+
+## How can I configure an IPFS node to use a custom `signaling endpoint` for my WebRTC transport?
+
+You'll need to execute a compatible `signaling server` ([libp2p-webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star) works) and include the correct configuration param for your IPFS node:
+
+- provide the [`multiaddr`](https://github.com/multiformats/multiaddr) for the `signaling server`
+
+```JavaScript
+const node = await IPFS.create({
+  repo: 'your-repo-path',
+  config: {
+    Addresses: {
+      Swarm: [
+        '/ip4/127.0.0.1/tcp/9090/ws/p2p-webrtc-star'
+      ]
+    }
+  }
+})
+```
+
+The code above assumes you are running a local `signaling server` on port `9090`. Provide the correct values accordingly.
+
+## I see some slowness when hopping between tabs Chrome with IPFS nodes, is there a reason why?
+
+Yes, unfortunately, due to [Chrome aggressive resource throttling policy](https://github.com/ipfs/js-ipfs/issues/611), it cuts freezes the execution of any background tab, turning an IPFS node that was running on that webpage into a vegetable state.
+
+A way to mitigate this in Chrome, is to run your IPFS node inside a Service Worker, so that the IPFS instance runs in a background process. You can learn how to install an IPFS node as a service worker in here the repo [ipfs-service-worker](https://github.com/ipfs/ipfs-service-worker)
+
+## Can I use IPFS in my Electron App?
+
+Yes you can and in many ways. Read https://github.com/ipfs/notes/issues/256 for the multiple options.
+
+We now support Electron v5.0.0 without the need to rebuilt native modules.
+Still if you run into problems with native modules follow these instructions [here](https://electronjs.org/docs/tutorial/using-native-node-modules).
+
+## What are all these `refs?Qmfoo` HTTP errors I keep seeing in the console?
+
+In order for content added to your node to be accessible to other nodes on the network, they need to be able to [dial](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/SWARM.md#ipfsswarmconnectaddr-options) your node. This means there needs to be some way of connecting to you from the open Internet.
+
+From node.js and Electron this might be done by opening a TCP port on your router and forwarding traffic to your node, while also configuring an [Announce](https://github.com/ipfs/js-ipfs/blob/master/docs/CONFIG.md#announce) address that is a combination of the forwarded port and your public IP address.
+
+Browsers [can't open TCP sockets](https://github.com/ipfs/js-ipfs/blob/master/docs/BROWSERS.md#limitations-of-the-browser-context) so the only way right now is for your node to be connected to a WebRTC-Star signalling server - nodes interested in your content would connect to the same WebRTC-Star server and use that to negotiate a peer-to-peer connection.
+
+This has several drawbacks - WebRTC is expensive so having lots of peers does not scale well, the maximum packet size is small so it's comparatively inefficient, browsers will frequently cull connections if you switch away from the tab and at the time of writing go-IPFS [has no WebRTC-Star transport](https://libp2p.io/implementations/#transports) so great swathes of the network will not be able to dial your node.
+
+To make your content available, several 'preload' nodes are running. These nodes expose their [refs endpoint](https://docs.ipfs.io/reference/http/api/#api-v0-refs) over HTTP and all js-IPFS nodes connect to them as peers on startup.
+
+When you add content to your node, a request is sent to a preload node with the CID of the content you've just added. This causes the preload node to use [Bitswap](https://docs.ipfs.io/concepts/bitswap/) to pull the content from your node, caching it for an hour or so which then means other nodes can then access the content without having to dial your otherwise undialable node.
+
+These nodes sometimes go down, which is why you see errors in the console. They are non-fatal and can be ignored.
+
+If you run your own node you can [disable preloading](https://github.com/ipfs/js-ipfs/blob/master/docs/MODULE.md#optionspreload) which will make the errors go away, at the cost of your content becoming less available or not available at all.
+
+## Have more questions?
+
+Ask for help in our forum at https://discuss.ipfs.io or in IRC (#ipfs on Freenode).
diff --git a/docs/IPLD.md b/docs/IPLD.md
@@ -0,0 +1,146 @@
+# IPLD Codecs <!-- omit in toc -->
+
+## Table of Contents <!-- omit in toc -->
+
+- [Overview](#overview)
+- [Bundled BlockCodecs](#bundled-blockcodecs)
+- [Bundled Multihashes](#bundled-multihashes)
+- [Bundled Multibases](#bundled-multibases)
+- [Adding additional BlockCodecs, Multihashes and Multibases](#adding-additional-blockcodecs-multihashes-and-multibases)
+- [Next steps](#next-steps)
+
+## Overview
+
+The IPFS repo contains a blockstore that holds the data that makes up the files on the IPFS network. These blocks can be thought of as a [CID][] and associated byte array.
+
+The [CID][] contains a `code` property that lets us know how to interpret the byte array associated with it.
+
+In order to perform that interpretation, a [BlockCodec][] must be loaded that corresponds to the `code` property of the [CID][].
+
+Similarly implementations of [Multihash][]es or [Multibase][]s must be available to be used.
+
+## Bundled BlockCodecs
+
+js-IPFS ships with four bundled codecs, the ones that are required to create and interpret [UnixFS][] structures.
+
+These are:
+
+1. [@ipld/dag-pb](https://github.com/ipld/js-dag-pb) - used for file and directory structures
+2. [raw](https://github.com/multiformats/js-multiformats/blob/master/src/codecs/raw.js) - used for file data where imported with `--raw-leaves=true`
+3. [@ipld/dag-cbor](https://github.com/ipld/js-dag-cbor) - used for storage of JavaScript Objects with [CID] links to other blocks
+4. [json](https://github.com/multiformats/js-multiformats/blob/master/src/codecs/json.js) - used for storage of plain JavaScript Objects
+
+## Bundled Multihashes
+
+js-IPFS ships with all multihashes [exported by js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/src/hashes), including `sha2-256` and others.
+
+Additional hashers can be configured using the `hashers` config property.
+
+## Bundled Multibases
+
+js-IPFS ships with all multibases [exported by js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/src/bases), including `base58btc`, `base32` and others.
+
+Additional bases can be configured using the `bases` config property.
+
+## Adding additional BlockCodecs, Multihashes and Multibases
+
+If your application requires support for extra codecs, you can configure them as follows:
+
+1. Configure the [IPLD layer](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs/docs/MODULE.md#optionsipld) of your IPFS daemon to support the codec. This step is necessary so the node knows how to prepare data received over HTTP to be passed to IPLD for serialization:
+
+    ```javascript
+    import { create } from 'ipfs'
+    import customBlockCodec from 'custom-blockcodec'
+    import customMultibase from 'custom-multibase'
+    import customMultihasher from 'custom-multihasher'
+
+    const node = await create({
+      ipld: {
+        // either specify BlockCodecs as part of the `codecs` list
+        codecs: [
+          customBlockCodec
+        ],
+
+        // and/or supply a function to load them dynamically
+        loadCodec: async (codecNameOrCode) => {
+          return import(codecNameOrCode)
+        },
+
+        // either specify Multibase codecs as part of the `bases` list
+        bases: [
+          customMultibase
+        ],
+
+        // and/or supply a function to load them dynamically
+        loadBase: async (baseNameOrCode) => {
+          return import(baseNameOrCode)
+        },
+
+        // either specify Multihash hashers as part of the `hashers` list
+        hashers: [
+          customMultihasher
+        ],
+
+        // and/or supply a function to load them dynamically
+        loadHasher: async (hashNameOrCode) => {
+          return import(hashNameOrCode)
+        }
+      }
+    })
+   ```
+
+2. Configure your IPFS HTTP API Client to support the codec. This is necessary so that the client can send the data to the IPFS node over HTTP:
+
+    ```javascript
+    import { create } from 'ipfs-http-client'
+    import customBlockCodec from 'custom-blockcodec'
+    import customMultibase from 'custom-multibase'
+    import customMultihasher from 'custom-multihasher'
+
+    const client = create({
+      url: 'http://127.0.0.1:5002',
+      ipld: {
+        // either specify BlockCodecs as part of the `codecs` list
+        codecs: [
+          customBlockCodec
+        ],
+
+        // and/or supply a function to load them dynamically
+        loadCodec: async (codecNameOrCode) => {
+          return import(codecNameOrCode)
+        },
+
+        // either specify Multibase codecs as part of the `bases` list
+        bases: [
+          customMultibase
+        ],
+
+        // and/or supply a function to load them dynamically
+        loadBase: async (baseNameOrCode) => {
+          return import(baseNameOrCode)
+        },
+
+        // either specify Multihash hashers as part of the `hashers` list
+        hashers: [
+          customMultihasher
+        ],
+
+        // and/or supply a function to load them dynamically
+        loadHasher: async (hashNameOrCode) => {
+          return import(hashNameOrCode)
+        }
+      }
+    })
+    ```
+
+## Next steps
+
+* See [examples/custom-ipld-formats](https://github.com/ipfs-examples/js-ipfs-examples/tree/master/examples/custom-ipld-formats) for runnable code that demonstrates the above with in-process IPFS nodes, IPFS run as a daemon and also the http client
+* Also [examples/traverse-ipld-graphs](https://github.com/ipfs-examples/js-ipfs-examples/tree/master/examples/traverse-ipld-graphs) which uses the [ipld-format-to-blockcodec](https://www.npmjs.com/package/ipld-format-to-blockcodec) module to use older [IPLD format][]s that have not been ported over to the new [BlockCodec][] interface, as well as additional [Multihash Hashers](https://www.npmjs.com/package/multiformats#multihash-hashers).
+
+[cid]: https://docs.ipfs.io/concepts/content-addressing/
+[blockcodec]: https://www.npmjs.com/package/multiformats#multicodec-encoders--decoders--codecs
+[unixfs]: https://github.com/ipfs/specs/blob/master/UNIXFS.md
+[ipld format]: https://github.com/ipld/interface-ipld-format
+[multihash]: https://github.com/multiformats/multihash
+[multibase]: https://github.com/multiformats/multibase
diff --git a/docs/MIGRATION-TO-ASYNC-AWAIT.md b/docs/MIGRATION-TO-ASYNC-AWAIT.md
diff --git a/docs/MODULE.md b/docs/MODULE.md
diff --git a/docs/MONITORING.md b/docs/MONITORING.md
@@ -0,0 +1,15 @@
+# Monitoring
+
+The HTTP API exposed with js-ipfs can also be used for exposing metrics about the running js-ipfs node and other Node.js metrics.
+
+To enable it, you need to set the environment variable `IPFS_MONITORING` (any value).  E.g.
+
+```console
+$ IPFS_MONITORING=true jsipfs daemon
+```
+
+Once the environment variable is set and the js-ipfs daemon is running, you can get the metrics (in prometheus format) by making a GET request to the following endpoint:
+
+```
+http://localhost:5002/debug/metrics/prometheus
+```
diff --git a/docs/README.md b/docs/README.md
@@ -0,0 +1,37 @@
+# IPFS Docs <!-- omit in toc -->
+
+- [API Docs](#api-docs)
+- [How tos and other documentation](#how-tos-and-other-documentation)
+- [Development documentation](#development-documentation)
+
+## API Docs
+
+`ipfs` can run as part of your program (an in-process node) or as a standalone daemon process that can be communicated with via an HTTP RPC API using the [`ipfs-http-client`](../packages/ipfs-http-client) module.
+
+Whether accessed directly or over HTTP, both methods support the full [Core API](#core-api).  In addition other methods are available to construct instances of each module, etc.
+
+* [Core API docs](./core-api/README.md)
+* [IPFS API](../packages/ipfs/README.md)
+* [IPFS-HTTP-CLIENT API](../packages/ipfs-http-client/README.md)
+
+## How tos and other documentation
+
+* [Architecture overview](./ARCHITECTURE.md)
+* [How to run js-IPFS in the browser](./BROWSERS.md)
+* [Running js-IPFS on the CLI](./CLI.md)
+* [js-IPFS configuration options](./CONFIG.md)
+* [How to configure CORS for use with the http client](./CORS.md)
+* [Running js-IPFS as a daemon](./DAEMON.md)
+* [Configuring Delegate Routers](./DELEGATE_ROUTERS.md)
+* [Running js-IPFS under Docker](./DOCKER.md)
+* [FAQ](./FAQ.md)
+* [How to configure additional IPLD codecs](./IPLD.md)
+* [Running js-IPFS in your application](./MODULE.md)
+* [How to get metrics out of js-IPFS](./MONITORING.md)
+
+## Development documentation
+
+* [Getting started](./DEVELOPMENT.md)
+* [Release issue template](./RELEASE_ISSUE_TEMPLATE.md)
+* [Early testers](./EARLY_TESTERS.md)
+* [Releases](./RELEASES.md)
diff --git a/docs/RELEASES.md b/docs/RELEASES.md
@@ -0,0 +1,112 @@
+# Releases <!-- omit in toc -->
+
+## Table of Contents <!-- omit in toc -->
+
+- [Release Philosophy](#release-philosophy)
+- [Release Flow](#release-flow)
+  - [Stage 0 - Automated Testing](#stage-0---automated-testing)
+  - [Stage 1 - Internal Testing](#stage-1---internal-testing)
+  - [Stage 2 - Community Dev Testing](#stage-2---community-dev-testing)
+  - [Stage 3 - Community Prod Testing](#stage-3---community-prod-testing)
+  - [Stage 4 - Release](#stage-4---release)
+- [Release Cycle](#release-cycle)
+  - [Patch Releases](#patch-releases)
+- [Performing a Release](#performing-a-release)
+- [Release Version Numbers](#release-version-numbers)
+  - [Release Candidates](#release-candidates)
+
+## Release Philosophy
+
+js-ipfs aims to have release every six weeks, two releases per quarter. During these 6 week releases, we go through 4 different stages that gives us the opportunity to test the new version against our test environments (unit, interop, integration), QA in our current production environment, IPFS apps (e.g. Desktop and WebUI) and with our community and _early testers_<sup>[1]</sup> that have IPFS running in production.
+
+We might expand the six week release schedule in case of:
+
+- No new updates to be added
+- In case of a large community event that takes the core team availability away (e.g. IPFS Conf, Dev Meetings, IPFS Camp, etc.)
+
+## Release Flow
+
+js-ipfs releases come in 5 stages designed to gradually roll out changes and reduce the impact of any regressions that may have been introduced. If we need to merge non-trivial<sup>[2]</sup> changes during the process, we start over at stage 0.
+
+![js-ipfs release flow cartoon](https://ipfs.io/ipfs/QmU5pwcGh38DqzLy3rK8GAHuWm2kK87oGqDAtqZYWhxjab)
+
+### Stage 0 - Automated Testing
+
+At this stage, we expect _all_ automated tests (unit, functional, integration, interop, testlab, performance, etc.) to pass.
+
+### Stage 1 - Internal Testing
+
+At this stage, we'll:
+
+1. Start a partial-rollout to our own infrastructure.
+2. Test against applications in the [ipfs](https://github.com/ipfs/) and [ipfs-shipyard](https://github.com/ipfs-shipyard/) organisations and a selection of other hand picked projects.
+
+**Goals:**
+
+1. Make sure we haven't introduced any obvious regressions.
+2. Test the release in an environment we can monitor and easily roll back (i.e. our own infra).
+
+### Stage 2 - Community Dev Testing
+
+At this stage, we'll announce the impending release to the community and ask for pre-release testers.
+
+**Goal:**
+
+Test the release in as many non-production environments as possible. This is relatively low-risk but gives us a _breadth_ of testing internal testing can't.
+
+### Stage 3 - Community Prod Testing
+
+At this stage, we consider the release to be "production ready" and will ask the community and our early testers to (partially) deploy the release to their production infrastructure.
+
+**Goals:**
+
+1. Test the release in some production environments with heavy workloads.
+2. Partially roll-out an upgrade to see how it affects the network.
+3. Retain the ability to ship last-minute fixes before the final release.
+
+### Stage 4 - Release
+
+At this stage, the release is "battle hardened" and ready for wide deployment. A new version is published to npm, announcements are made and a blog post is published to [blog.ipfs.io](https://blog.ipfs.io).
+
+## Release Cycle
+
+A full release process should take about 3 weeks, a week per stage 1-3. We will start a new process every 6 weeks, regardless of when the previous release landed unless it's still ongoing.
+
+### Patch Releases
+
+If we encounter a serious bug in the stable latest release, we will create a patch release based on this release. For now, bug fixes will _not_ be backported to previous releases.
+
+Patch releases will usually follow a compressed release cycle and should take 2-3 days. In a patch release:
+
+1. Automated and internal testing (stage 0 and 1) will be compressed into a few hours - ideally less than a day.
+2. Stage 2 will be skipped.
+3. Community production testing will be shortened to 1-2 days of opt-in testing in production (early testers can choose to pass).
+
+Some patch releases, especially ones fixing one or more complex bugs, may undergo the full release process.
+
+## Performing a Release
+
+The release is managed by the "Lead Maintainer" for js-ipfs. It starts with the opening of an issue containing the content available on the [RELEASE_ISSUE_TEMPLATE](./RELEASE_ISSUE_TEMPLATE.md) not more than **48 hours** after the previous release.
+
+This issue is pinned and labeled ["release"](https://github.com/ipfs/js-ipfs/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3Arelease). When the cycle is due to begin the 5 stages will be followed until the release is done.
+
+## Release Version Numbers
+
+js-ipfs is currently pre-1.0. In semver terms this means [anything may change at any time](https://semver.org/#spec-item-4).
+
+However, pre-1.0 js-ipfs reserves MINOR version increments for BREAKING CHANGES _and_ feature additions and PATCH version increments for bug fixes.
+
+Post `1.x.x` (future), MAJOR version number increments will contain BREAKING CHANGES, MINOR version increments will be reserved for backwards compatible new features and PATCH version increments for bug fixes.
+
+We do not yet retroactively apply fixes to older releases (no Long Term Support releases for now), which means that we always recommend users to update to the latest, whenever possible.
+
+### Release Candidates
+
+Every commit to master results in the publishing of a Release Candidate. These are made available for users who want to try out the "bleeding edge" and can be installed using version numbers with the form `x.y.z-rc.n` where `x`, `y`, and `z` are the usual MAJOR, MINOR and PATCH version numbers and `n` (starting at 0) which is the number of commits to master since the last full release.
+
+Alternatively the latest RC is tagged `next` on npm and can be installed using `npm install ipfs@next`.
+
+---
+
+- <sup>**[1]**</sup> - _early testers_ is an IPFS programme in which members of the community can self-volunteer to help test `js-ipfs` Release Candidates. You find more info about it at [EARLY_TESTERS.md](./EARLY_TESTERS.md)
+- <sup>**[2]**</sup> - A non-trivial change is any change that could potentially introduce an issue that could not categorically be caught by automated testing. This is up to the discretion of the Lead Maintainer but the assumption is that every change is non-trivial unless proven otherwise.
diff --git a/docs/RELEASE_ISSUE_TEMPLATE.md b/docs/RELEASE_ISSUE_TEMPLATE.md
@@ -21,7 +21,7 @@
 # ✅ Release Checklist
 
 - [ ] **Stage 0 - Automated Testing**
-  - [ ] Feature freeze. If any "non-trivial" changes (see the footnotes of [doc/releases.md](https://github.com/ipfs/js-ipfs/tree/master/doc/releases.md) for a definition) get added to the release, uncheck all the checkboxes and return to this stage.
+  - [ ] Feature freeze. If any "non-trivial" changes (see the footnotes of [docs/releases.md](https://github.com/ipfs/js-ipfs/tree/master/docs/releases.md) for a definition) get added to the release, uncheck all the checkboxes and return to this stage.
   - [ ] Automated Testing (already tested in CI) - Ensure that all tests are passing, this includes:
     - [ ] unit/functional/integration/e2e
     - [ ] interop
@@ -32,7 +32,6 @@
       - [ ] ~~[ipfs-desktop](https://github.com/ipfs-shipyard/ipfs-desktop)~~ (Does not depend on `js-ipfs` or `js-ipfs-http-client`)
       - [ ] [ipfs-companion](https://github.com/ipfs-shipyard/ipfs-companion)
       - [ ] [npm-on-ipfs](https://github.com/ipfs-shipyard/npm-on-ipfs)
-      - [ ] [ipfs-pubsub-room](https://github.com/ipfs-shipyard/ipfs-pubsub-room)
       - [ ] [peer-base](https://github.com/peer-base/peer-base)
       - [ ] [service-worker-gateway](https://github.com/ipfs-shipyard/service-worker-gateway)
     - [ ] Third party application testing
@@ -47,34 +46,35 @@
       - [ ] Packages Listing
   - [ ] Publish a release candidate to npm
     ```sh
-    # All succesful builds of master update the `build/last-successful branch which
-    # contains a npm-shrinkwrap.json.
+    # All successful builds of master update the `build/last-successful` branch
+    # which contains an `npm-shrinkwrap.json`.
     # This command checks that branch out, installs it's dependencies using `npm ci`,
     # creates a release branch (e.g. release/v0.34.x), updates the minor prerelease
-    # version (e.g. 0.33.1 -> 0.34.0-rc.0) and publishes it to npm
+    # version (e.g. 0.33.1 -> 0.34.0-rc.0) and publishes it to npm.
     npx aegir publish-rc
 
-    # Later we may wish to update the rc.  First cherry-picked/otherwise merged the
-    # new commits into the release  branch on github (e.g. not locally) and wait
-    # for CI to pass.  First update the lockfiles used by ci (n.b. one  day this
-    # will be done by our ci tools):
+    # Later we may wish to update the rc. First cherry-pick/otherwise merge the
+    # new commits into the release branch on github (e.g. not locally) and wait
+    # for CI to pass. Then update the lockfiles used by CI (n.b. one day this
+    # will be done by our ci tools) with this command:
     npx aegir update-release-branch-lockfiles release/v0.34.x
 
-    # Then update the rc publisehd on npm.  This command pulls the specified release
-    # branch, installs it's dependencies `npm ci`, increments the prerelease version
-    # (e.g. 0.34.0-rc.0 -> 0.34.0-rc.1) and publishes it to npm
+    # Then update the rc published on npm. This command pulls the specified
+    # release branch, installs it's dependencies `npm ci`, increments the
+    # prerelease version (e.g. 0.34.0-rc.0 -> 0.34.0-rc.1) and publishes it
+    # to npm.
     npx aegir update-rc release/v0.34.x
     ```
   - Network Testing:
     - test lab things - TBD
   - Infrastructure Testing:
     - TBD
-  - [ ] **Stage 2 - Community Dev Testing**
-  - [ ] Reach out to the IPFS _early testers_ listed in [doc/EARLY_TESTERS.md](https://github.com/ipfs/js-ipfs/tree/master/doc/EARLY_TESTERS.md) for testing this release (check when no more problems have been reported). If you'd like to be added to this list, please file a PR.
+- [ ] **Stage 2 - Community Dev Testing**
+  - [ ] Reach out to the IPFS _early testers_ listed in [docs/EARLY_TESTERS.md](https://github.com/ipfs/js-ipfs/tree/master/docs/EARLY_TESTERS.md) for testing this release (check when no more problems have been reported). If you'd like to be added to this list, please file a PR.
   - [ ] Reach out on IRC for additional early testers.
 - [ ] **Stage 3 - Community Prod Testing**
   - [ ] Update [js.ipfs.io](https://js.ipfs.io) examples to use the latest js-ipfs
-  - [ ] Invite the IPFS [_early testers_](https://github.com/ipfs/js-ipfs/tree/master/doc/EARLY_TESTERS.md) to deploy the release to part of their production infrastructure.
+  - [ ] Invite the IPFS [_early testers_](https://github.com/ipfs/js-ipfs/tree/master/docs/EARLY_TESTERS.md) to deploy the release to part of their production infrastructure.
   - [ ] Invite the wider community (link to the release issue):
     - [ ] [discuss.ipfs.io](https://discuss.ipfs.io/c/announcements)
     - [ ] Twitter

diff --git a/docs/config.md b/docs/config.md
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		{"packages/interface-ipfs-core":"0.158.1","packages/ipfs":"0.66.1","packages/ipfs-cli":"0.16.1","packages/ipfs-client":"0.10.1","packages/ipfs-core":"0.18.1","packages/ipfs-core-config":"0.7.1","packages/ipfs-core-types":"0.14.1","packages/ipfs-core-utils":"0.18.1","packages/ipfs-daemon":"0.16.1","packages/ipfs-grpc-client":"0.13.1","packages/ipfs-grpc-protocol":"0.8.1","packages/ipfs-grpc-server":"0.12.1","packages/ipfs-http-client":"60.0.1","packages/ipfs-http-gateway":"0.13.1","packages/ipfs-http-response":"6.0.1","packages/ipfs-http-server":"0.15.1","packages/ipfs-message-port-client":"0.15.1","packages/ipfs-message-port-protocol":"0.15.1","packages/ipfs-message-port-server":"0.15.1"}