level-supports 6.x

Complete instructions

Verified against level-supports@6.2.0 on 2026-09-08. 6 of 6 examples executed.

level-supports

Scope

level-supports creates capability manifests for abstract-level databases. Version 6 is not compatible with levelup or abstract-leveldown. Node.js 16 or newer is required.

The package is ordinary module code, not a test runner or CLI. Import its named supports export and attach the resulting manifest to a database object yourself.

Import the v6 API

import assert from 'node:assert/strict'
import { supports } from 'level-supports'

const manifest = supports()
assert.equal(manifest.seek, false)
assert.equal(manifest.permanence, false)
assert.deepEqual(manifest.encodings, {})
assert.deepEqual(manifest.events, {})
assert.deepEqual(manifest.additionalMethods, {})
assert.deepEqual(manifest.signals, {})

A common migration mistake is retaining the old v2 default-import shape:

// v2 / older code — do not use with v6
const supports = require('level-supports')

Use the v6 named export instead:

const { supports } = require('level-supports')

Build a manifest

Pass a partial manifest to supports() and assign the result to the database's supports property:

import assert from 'node:assert/strict'
import { supports } from 'level-supports'

const db = { supports: supports({
  permanence: false,
  seek: true,
  encodings: {
    utf8: true,
    json: true
  },
  events: {
    put: true
  },
  additionalMethods: {
    compact: true
  },
  signals: {
    iterators: true
  }
}) }

assert.equal(db.supports.permanence, false)
assert.equal(db.supports.seek, true)
assert.equal(db.supports.encodings.utf8, true)
assert.equal(db.supports.encodings.json, true)
assert.equal(db.supports.events.put, true)
assert.equal(db.supports.additionalMethods.compact, true)
assert.equal(db.supports.signals.iterators, true)

The top-level capability fields documented for v6 are snapshots, permanence, seek, createIfMissing, errorIfExists, deferredOpen, and streams. Nested capability groups are encodings, events, additionalMethods, and signals. Snapshot-related manifests also expose implicitSnapshots and explicitSnapshots; snapshots is the backwards-compatible snapshot alias.

Merge manifests

supports() accepts zero or more partial manifests. Later top-level properties overwrite earlier ones. Nested capability objects are also replaced as properties of the merged manifest; they are not recursively combined.

import assert from 'node:assert/strict'
import { supports } from 'level-supports'

const merged = supports(
  {
    seek: true,
    encodings: { utf8: true },
    events: { put: true }
  },
  {
    seek: false,
    encodings: { json: true }
  }
)

assert.equal(merged.seek, false)
assert.deepEqual(merged.encodings, { json: true })
assert.deepEqual(merged.events, { put: true })

If you need both encoding declarations, include both in the same input object rather than expecting nested objects from earlier manifests to be merged.

Test capabilities by truthiness

Feature values are not coerced to the boolean true. Falsy or absent top-level properties become false, while truthy values are retained. Test support with truthiness, not === true.

import assert from 'node:assert/strict'
import { supports } from 'level-supports'

const manifest = supports(
  { seek: true, permanence: 1 },
  { seek: { mode: 'fast' } }
)

assert.deepEqual(manifest.seek, { mode: 'fast' })
assert.equal(manifest.permanence, 1)
assert.equal(Boolean(manifest.seek), true)
assert.notEqual(manifest.seek, true)

const unsupported = supports({ seek: false })
assert.equal(unsupported.seek, false)
assert.equal(Boolean(unsupported.seek), false)

The same rule applies to snapshot-related capability values and other top-level feature properties. Do not assume every supported value is literally true.

Snapshot capabilities

Use the snapshot fields when describing database snapshot support. The manifest surface includes implicitSnapshots, the backwards-compatible snapshots alias, and explicitSnapshots.

import assert from 'node:assert/strict'
import { supports } from 'level-supports'

const manifest = supports({
  implicitSnapshots: true,
  snapshots: true,
  explicitSnapshots: false
})

assert.equal(manifest.implicitSnapshots, true)
assert.equal(manifest.snapshots, true)
assert.equal(manifest.explicitSnapshots, false)
assert.equal(Boolean(manifest.implicitSnapshots), true)

Signals and iterators

In v6, signals.iterators describes signal support for db.iterator(), db.keys(), and db.values(). The manifest only declares the capability; it does not create an iterator or an AbortController integration.

import assert from 'node:assert/strict'
import { supports } from 'level-supports'

const manifest = supports({
  signals: { iterators: true }
})

assert.equal(manifest.signals.iterators, true)
if (manifest.signals.iterators) {
  const controller = new AbortController()
  assert.ok(controller.signal)
}

v6 versus older manifests

Do not copy the v2 manifest shape into v6 code. Older documentation described fields such as bufferKeys, openCallback, promises, status, and clear, and described encodings as a boolean. In v6, encodings is an object of encoding capabilities and cannot be false; the v6 surface instead documents the fields and nested groups listed above.

Does not cover

This skill does not cover opening or operating an abstract-level database, implementing any declared capability, iterator behavior, abort behavior, or integration with a particular database package. It also does not cover the old levelup or abstract-leveldown APIs, package installation, or CLI/test-runner usage.