mise.toml

# Require a mise new enough for the [deps] providers and the [hooks.postinstall]
# table form used below; older versions fail to parse this file.  Environments
# that intentionally ship an older mise and don't need this tooling (e.g. the
# Netlify build for the static schema site) opt out by setting
# MISE_IGNORED_CONFIG_PATHS to this file's path; see schema/netlify.toml.
min_version = "2026.11.6"

[settings]
# Required by the [deps] dependency providers below, which are still an
# experimental mise feature.
experimental = true

[tools]
bun = "1.2.22"
deno = "2.9.7"
node = "22"
pnpm = "10.28.0"
"aqua:dahlia/hongdown" = "0.5.3"
# Nushell powers the cross-platform orchestration tasks (prepare-each,
# check-each, test-each, check-versions) so they run identically on Windows,
# macOS, and Linux without Bash.
"aqua:nushell/nushell" = "0.114.0"
"github:dahlia/sacho" = "0.3.3"

# Dependency providers <https://mise.jdx.dev/dev-tools/deps.html>
#
# These replace the old hand-rolled `install` task.  With `auto = true` mise
# runs them automatically before any `mise run`/`mise x`, and the
# `sources`/`outputs` make each one a no-op once it is up to date.  The
# `postinstall` hook below also runs them, so a fresh checkout is fully set up
# by a single `mise install`.

# Install dependencies first. pnpm links every workspace before the root prepare
# lifecycle builds packages; vocab's build generates its sources using Node.js.
# Keep native dependency lifecycle scripts enabled.
[deps.pnpm-install]
auto = true
sources = [
  "package.json",
  "pnpm-workspace.yaml",
  "pnpm-lock.yaml",
  "packages/*/package.json",
  "docs/package.json",
  "examples/*/package.json",
  "examples/*/*/package.json",
  "test/smoke/harness/package.json",
]
outputs = ["node_modules/.modules.yaml"]
run = "pnpm install"

# Source imports let the generator run before any package has dist/ output.
# On a fresh install, prepare already generated vocab.ts; this self-skips.
[deps.codegen]
auto = true
depends = ["pnpm-install"]
sources = [
  # Match loadSchemaFiles()'s case-insensitive /\.ya?ml$/ expression.
  "packages/vocab/src/**/*.[yY][aA][mM][lL]",
  "packages/vocab/src/**/*.[yY][mM][lL]",
  "packages/vocab/scripts/**/*.ts",
  "packages/vocab/package.json",
  ".oxfmtrc.json",
  "package.json",
  "pnpm-workspace.yaml",
  "packages/vocab-tools/src/**/*.ts",
  "packages/vocab-tools/src/**/*.[yY][aA][mM][lL]",
  "packages/vocab-tools/src/**/*.[yY][mM][lL]",
  # codec.ts and property.ts embed the generator's package metadata.
  "packages/vocab-tools/deno.json",
]
outputs = ["packages/vocab/src/vocab.ts"]
run = "node --experimental-strip-types packages/vocab/scripts/codegen.ts"

# Hooks <https://mise.jdx.dev/hooks.html>
#
# After tools are installed/updated, finish bootstrapping the checkout so that
# `mise install` alone leaves a fresh clone ready to use:
#
#  1. install project dependencies via the deps providers above, and
#  2. install the Git pre-commit hook, but only when one is not already present
#     -- this keeps repeat `mise install` runs quiet and never clobbers an
#     existing hook.  Use `mise run hooks:install` to (re)install it explicitly.
[hooks.postinstall]
shell = "nu -c"
run = '''
mise deps
sacho init --no-interactive
# Only touch the Git hook when git is actually available; in minimal
# environments (e.g. some containers) git may be missing, and invoking it
# unguarded would fail the whole postinstall hook.
if (which git | is-not-empty) {
  if (git rev-parse --is-inside-work-tree | complete | get exit_code) == 0 {
    let hook = (git rev-parse --git-path hooks/pre-commit | str trim)
    if not ($hook | path exists) {
      print "Installing Git pre-commit hook..."
      mise generate git-pre-commit --write --task=check
    }
  }
}
'#!/bin/sh
sacho hook-commit-msg "$1"' | save --force .git/hooks/commit-msg
'#!/bin/sh
if test "$1" = prepared; then
  sacho_state=$(git rev-parse --git-path sacho-commit-state) || exit $?
  if test -f "$sacho_state"; then
    sacho hook-reference-transaction "$1"
  fi
fi' | save --force .git/hooks/reference-transaction
if $nu.os-info.name != 'windows' {
  chmod +x .git/hooks/commit-msg .git/hooks/reference-transaction
}
'''

# Code generation
[tasks.codegen]
description = "Generate ActivityPub vocabulary types from YAML definitions"
# Auto dependency providers install the generator dependencies first. Calling
# the script directly avoids forcing a new pnpm install for an explicit run.
run = "node --experimental-strip-types packages/vocab/scripts/codegen.ts"

# Deno entry points depend on this task explicitly while tooling is migrated.
# Keep it out of automatic dependency providers so Node-only bootstrap stays
# usable without Deno.
[tasks."deno:cache"]
description = "Prepare workspace exports for Deno compatibility work"
env = { DENO_LOG = "error" }
sources = [
  "deno.lock",
  "deno.json",
  "packages/*/deno.json",
  "examples/*/deno.json",
  "examples/*/*/deno.json",
  # Deno also resolves dependencies declared in workspace npm manifests.
  "package.json",
  "packages/*/package.json",
  "examples/*/package.json",
  "examples/*/*/package.json",
  "scripts/install.ts",
  "packages/vocab/src/vocab.ts",
]
outputs = ["node_modules/.cache/fedify-deno-precache.stamp"]
run = "deno run --allow-read --allow-env --allow-run --allow-write scripts/install.ts"

[tasks."codegen:check:deno"]
depends = ["deno:cache"]
description = "Validate generated vocabulary formatting and Deno types"
run = [
  "pnpm exec oxfmt --check -c .oxfmtrc.json packages/vocab/src/vocab.ts",
  "deno check packages/vocab/src/vocab.ts",
]

[tasks."test:codegen"]
description = "Test code generation freshness, locking, and failure handling"
run = "node --experimental-strip-types --test packages/vocab/scripts/codegen.test.ts"

# Build
#
# No explicit `depends = ["codegen"]`: the auto [deps.codegen] provider already
# ensures vocab.ts exists before any task, and @fedify/vocab's own `build:self`
# regenerates it.  Depending on `codegen` here would defeat the
# `sources`/`outputs` cache below, because the codegen script self-skips without
# rewriting its output, so mise always considers that task non-fresh and would
# re-run this build with it.  The outputs glob ends in `/**/*` (not a bare
# `/**`) so mise's freshness check matches the emitted files.
[tasks.build]
description = "Build all packages"
env = { CI = "true" } # Prevent pnpm from prompting for confirmation
# Run through Nushell so the single-quoted pnpm filter is parsed consistently on
# every platform.  With the default shell, Windows `cmd` does not strip the
# single quotes, so pnpm would receive the literal `'!./examples/**'`, match no
# projects, and turn the build into a silent no-op.
shell = "nu -c"
sources = [
  # Everything under src/, not just *.ts(x): some packages copy non-TypeScript
  # assets into dist (e.g. @fedify/init's templates and @fedify/fixture's JSON
  # fixtures), and those are real build inputs too.
  "packages/*/src/**/*",
  "packages/*/tsdown.config.ts",
  "packages/*/package.json",
  "packages/*/deno.json",
]
outputs = ["packages/*/dist/**/*"]
run = "pnpm --recursive --filter='!./examples/**' run build:self"

[tasks.prepare-each]
description = "Build specific package(s)"
usage = 'arg "<packages>" help="Package name(s) (without @fedify/ prefix)" var=#true var_min=1'
env = { CI = "true" }
shell = "nu -c"
run = '''
for pkg in ($env.usage_packages | split row " " | where ($it | is-not-empty)) {
  print $"Preparing package: ($pkg)"
  pnpm --filter $"@fedify/($pkg)" build
}
'''

# Code quality
[tasks.check]
description = "Check code formatting, linting, and type checking"
depends = [
  "check:fmt",
  "check:lint",
  "check:types",
  "check:md",
  "check-versions",
  "check:workspace-protocol",
  "check:fixture-usage",
  "check:node-modules",
  "test:docs-contributors",
  "test:docs-twoslash",
  "test:codegen",
  "test:changelog-pr-refs",
  "test:tooling",
]
run = "sacho check"

[tasks."check:all"]
description = "Check code quality including Deno compatibility"
depends = ["check", "codegen:check:deno", "check:types:deno"]

[tasks."check:node-modules"]
description = "Check that Deno leaves pnpm's node_modules directories alone"
run = "node scripts/check_node_modules.mjs"

[tasks."check:fmt"]
description = "Check code formatting with Oxfmt"
run = "pnpm exec oxfmt --check -c .oxfmtrc.json . packages/vocab/src/vocab.ts"

[tasks."check:lint"]
description = "Check code linting"
run = [
  "node --experimental-strip-types scripts/check_lint_directives.ts",
  "pnpm exec oxlint --quiet -c .oxlintrc.json . packages/vocab/src/vocab.ts",
]

[tasks.lint]
description = "Lint the codebase with Oxlint"
run = [
  "node --experimental-strip-types scripts/check_lint_directives.ts",
  "pnpm exec oxlint -c .oxlintrc.json . packages/vocab/src/vocab.ts",
]

# Type-checks against the built declarations of workspace packages, so it
# depends on `build` rather than `codegen` (see the note on `build`).
[tasks."check:types"]
description = "Check TypeScript types with TypeScript on Node.js"
depends = ["build"]
usage = 'arg "[packages]" help="Package name(s) to check (without @fedify/ prefix); all projects if omitted" var=#true'
shell = "nu -c"
run = """
let packages = ($env.usage_packages? | default "" | split row " " | where ($it | is-not-empty))
node --experimental-strip-types scripts/check_types.ts ...$packages
"""

[tasks."check:types:deno"]
description = "Check TypeScript types of the Deno workspace with deno check"
depends = ["deno:cache", "codegen"]
env = { DENO_LOG = "error" }
run = "deno --quiet run --allow-read --allow-env --allow-run --allow-sys scripts/check_types_deno.ts"

[tasks."check:md"]
description = "Check Markdown formatting"
run = "hongdown --check"

[tasks.check-versions]
description = "Check that all package versions are consistent across the monorepo"
usage = """
flag "--fix" help="Automatically fix package metadata version mismatches"
flag "--skip-next" help="Skip checking changes.d/next.txt"
"""
shell = "nu -c"
run = '''
let fix_args = if (($env.usage_fix? | default "false") == "true") { ["--fix"] } else { [] }
let skip_next_args = if (($env.usage_skip_next? | default "false") == "true") { ["--skip-next"] } else { [] }
node --experimental-strip-types scripts/check_versions.ts ...$fix_args ...$skip_next_args
'''

[tasks."check:fixture-usage"]
description = "Ensure @fedify/fixture is only used in **/*.test.ts files"
run = "node --experimental-strip-types scripts/check_fixture_usage.ts"

[tasks."check:changelog-pr-refs"]
description = "Check that changelog entries added by a pull request reference it"
run = "node --experimental-strip-types scripts/check_changelog_pr_refs.ts"

[tasks."test:changelog-pr-refs"]
description = "Test the changelog pull request reference check"
run = "node --experimental-strip-types --test scripts/check_changelog_pr_refs.test.ts"

[tasks."check:workspace-protocol"]
description = "Check for invalid workspace: specifiers without version (*, ^, ~)"
run = "node --experimental-strip-types scripts/check_workspace_protocol.ts"

[tasks.fmt]
description = "Format code with Oxfmt and Markdown with Hongdown and Sacho"
run = ["pnpm exec oxfmt -c .oxfmtrc.json .", "hongdown --write", "sacho fmt"]

[tasks.check-each]
depends = ["build"]
description = "Check code quality for specific package(s)"
usage = 'arg "<packages>" help="Package name(s) (without @fedify/ prefix)" var=#true var_min=1'
shell = "nu -c"
run = '''
for pkg in ($env.usage_packages | split row " " | where ($it | is-not-empty)) {
  print $"Checking package: ($pkg)"
  let dir = $"packages/($pkg)"
  if not ($dir | path exists) {
    print --stderr $"Error: Package directory ($dir) not found"
    exit 1
  }
  pnpm exec oxfmt --check -c .oxfmtrc.json $dir
  if $pkg == "vocab" {
    pnpm exec oxfmt --check -c .oxfmtrc.json packages/vocab/src/vocab.ts
  }
  let lint_paths = if $pkg == "vocab" {
    [$dir "packages/vocab/src/vocab.ts"]
  } else {
    [$dir]
  }
  node --experimental-strip-types scripts/check_lint_directives.ts $dir
  pnpm exec oxlint --quiet -c .oxlintrc.json ...$lint_paths
  # Deno-only packages (no package.json) keep their Deno type check.
  if ($"($dir)/package.json" | path exists) {
    node --experimental-strip-types scripts/check_types.ts $pkg
  } else {
    mise run deno:cache
    deno check $dir
  }
}
'''

# Testing
[tasks."test:pack"]
description = "Check that Deno preserves pnpm links and package packing"
run = "node scripts/test_pack.mjs"

[tasks."test:package-files"]
description = "Check JSR and npm packages exclude repository test assets"
depends = ["test:package-files:npm", "test:package-files:jsr"]

[tasks."test:package-files:npm"]
description = "Check npm package files and exports without Deno"
depends = ["build"]
run = ["node --test scripts/package_exports.test.mjs", "node scripts/test_package_files.mjs --npm"]

[tasks."test:package-files:jsr"]
description = "Check JSR package files and exports"
depends = ["deno:cache"]
run = "node scripts/test_package_files.mjs --jsr"

[tasks."test:npm-pack"]
description = "Check serialized npm packing with lifecycle hooks enabled"
depends = ["build"]
run = "node scripts/test_npm_pack.mjs"

[tasks."test:testing:pack"]
description = "Check @fedify/testing tarballs in isolated Node.js and Bun consumers"
depends = ["build"]
run = "node scripts/test_testing_pack.mjs"

[tasks."test:deno"]
depends = ["deno:cache", "build"]
description = "Run the test suite using Deno"
env = { FEDIFY_REQUIRE_OXLINT_TESTS = "1" }
run = "deno test --check --doc --allow-all --unstable-kv --trace-leaks --parallel"

[tasks."test:node"]
description = "Run the test suite using Node.js"
depends = ["build"]
env = { FEDIFY_REQUIRE_OXLINT_TESTS = "1" }
# See the note on `build`: Nushell keeps the single-quoted pnpm filter working
# on Windows, where `cmd` would otherwise pass it through literally.
# Keep package-level concurrency bounded because each `node --test` command
# also starts test workers.  Running every package at once can exhaust CI
# runner resources and make timing-sensitive tests fail under contention.
shell = "nu -c"
run = "pnpm run --recursive --parallel --workspace-concurrency=4 --filter '!{docs}' --config.enable-pre-post-scripts=false test"

[tasks."test:cfworkers"]
description = "Run the full Cloudflare Workers suite and harness selftests"
depends = ["build"]
run = "pnpm --filter @fedify/fedify test:cfworkers"

[tasks."test:bun"]
description = "Run the test suite using Bun"
depends = ["build"]
shell = "nu -c"
run = "pnpm run --recursive --parallel --filter '!{docs}' --config.enable-pre-post-scripts=false test:bun"

[tasks.test]
description = "Run checks and the package test suite using Node.js"
depends = ["check", "test:node"]

[tasks."test:all"]
description = "Run checks and compatibility suites across all supported runtimes"
depends = [
  "check:all",
  "test:deno",
  "test:node",
  "test:bun",
  "test:astro-compat",
  "test:sveltekit-compat",
  "test:temporal-polyfill",
  "test:pack",
  "test:testing:pack",
]

[tasks."test:temporal-polyfill"]
description = "Check Temporal polyfill packaging"
depends = ["build"]
run = "node --experimental-strip-types scripts/check_temporal_polyfill.ts"

[tasks.test-each]
depends = ["deno:cache"]
description = "Run tests for a specific package across all environments"
env = { FEDIFY_REQUIRE_OXLINT_TESTS = "1" }
usage = 'arg "<packages>" help="Package name(s) (without @fedify/ prefix)" var=#true var_min=1'
shell = "nu -c"
run = '''
let pkgs = ($env.usage_packages | split row " " | where ($it | is-not-empty))
mise run prepare-each ...$pkgs
for pkg in $pkgs {
  mise run check-each $pkg
  if ($"packages/($pkg)/deno.json" | path exists) {
    print $"Running Deno tests for package: ($pkg)"
    deno task --filter $"@fedify/($pkg)" test
  }
  if ($"packages/($pkg)/package.json" | path exists) {
    print $"Running Node.js tests for package: ($pkg)"
    pnpm --filter $"@fedify/($pkg)" test
    print $"Running Bun tests for package: ($pkg)"
    pnpm --filter $"@fedify/($pkg)" test:bun
  }
}
'''

[tasks."test-each:node"]
description = "Check and test selected packages using Node.js"
env = { FEDIFY_REQUIRE_OXLINT_TESTS = "1" }
usage = 'arg "<packages>" help="Package name(s) (without @fedify/ prefix)" var=#true var_min=1'
shell = "nu -c"
run = '''
let pkgs = ($env.usage_packages | split row " " | where ($it | is-not-empty))
mise run prepare-each ...$pkgs
for pkg in $pkgs {
  if not ($"packages/($pkg)/package.json" | path exists) {
    error make {msg: $"($pkg) has no Node.js package; use test-each for Deno-only packages"}
  }
  mise run check-each $pkg
  pnpm --filter $"@fedify/($pkg)" test
}
'''

[tasks."test:examples"]
description = "Run tests for all example projects"
# `build` produces @fedify/lint's dist/oxlint.js loader and provisions the
# prebuilt oxlint native binary into node_modules (via the pnpm deps provider) —
# both are needed by the lint/oxlint example.
depends = ["build"]
run = "node --experimental-strip-types examples/test-examples/mod.ts"

[tasks."test:astro-compat"]
description = "Test @fedify/astro against supported Astro and runtime versions"
depends = ["build"]
run = "node --experimental-transform-types packages/astro/compat/run.ts"

[tasks."test:sveltekit-compat"]
description = "Check @fedify/sveltekit consumer types against SvelteKit 2 and 3"
depends = ["build"]
run = "node --experimental-strip-types packages/sveltekit/compat/run.ts"

[tasks."test:monitoring"]
description = "Validate the monitoring example configuration"
run = "node --experimental-strip-types examples/monitoring/validate.ts"

[tasks."test:init"]
description = "Run tests for the init package"
depends = ["build"]
run = "node --experimental-transform-types packages/init/src/test/mod.ts test-init"

# Snapshot updates
# vocab keeps Deno.inspect() snapshots; vocab-tools has snapshots for every runtime.
# vocab-tools has separate snapshots for each runtime
[tasks."test:deno:update_snapshots"]
depends = ["deno:cache"]
description = "Update test snapshots for Deno"
run = [
  "deno task -f @fedify/vocab-tools test -- --update",
  "deno task -f @fedify/vocab test -- --update",
]

[tasks."test:node:update_snapshots"]
description = "Update test snapshots for Node.js"
run = "pnpm --filter @fedify/vocab-tools test:update_snapshots"

[tasks."test:bun:update_snapshots"]
description = "Update test snapshots for Bun"
run = "pnpm --filter @fedify/vocab-tools test:bun:update_snapshots"

[tasks."test:update_snapshots"]
description = "Update test snapshots for all environments (Deno, Node.js, Bun)"
depends = [
  "test:deno:update_snapshots",
  "test:node:update_snapshots",
  "test:bun:update_snapshots",
]

# Documentation
[tasks.docs]
description = "Start the documentation development server"
run = "pnpm -C docs dev"

[tasks."docs:build"]
description = "Build the documentation for production"
run = "pnpm -C docs build"

[tasks."test:docs-contributors"]
description = "Test the team page contributor loading and filtering"
run = "node --experimental-strip-types --test docs/.vitepress/contributors.test.mts"

[tasks."test:docs-twoslash"]
description = "Test the installed Twoslash popup optimization through VitePress"
run = "node --experimental-strip-types --test docs/.vitepress/twoslash-renderer.test.mts"

[tasks."docs:preview"]
description = "Preview the built documentation"
run = "pnpm -C docs preview"

# Benchmarks
[tasks.bench]
depends = ["deno:cache"]
description = "Run benchmarks"
run = "deno task -f @fedify/fedify bench"

# CLI and utilities
[tasks.cli]
depends = ["build"]
description = "Run the local Fedify CLI using Node.js"
run = "node --disable-warning=ExperimentalWarning packages/cli/dist/mod.js"

[tasks."cli:deno"]
depends = ["deno:cache"]
description = "Run the local Fedify CLI source using Deno"
run = "deno task -f @fedify/cli run"

[tasks.tunnel]
depends = ["build"]
description = "Tunnel port with the local Node.js Fedify CLI"
run = "node --disable-warning=ExperimentalWarning packages/cli/dist/mod.js tunnel"

[tasks.update-init-deps]
description = "Update third-party dependency versions in fedify init templates"
run = "node --experimental-strip-types packages/init/scripts/update_init_deps.ts"

[tasks."generate:bench-schema"]
description = "Regenerate the published benchmark JSON Schemas in schema/bench/"
run = "node --experimental-strip-types packages/cli/scripts/generate-bench-schema.ts"

[tasks."hooks:install"]
description = "Install Git hooks for pre-commit checks"
run = "mise generate git-pre-commit --write --task=check"

[tasks.bump-version]
description = "Bump the version of all packages in the monorepo"
usage = """
arg "<version>" help="New version (e.g., 1.2.3, major, minor, patch)"
"""
shell = "nu -c"
run = """
sacho next $env.usage_version
open packages/fedify/deno.json |
  upsert version $env.usage_version |
  save --force packages/fedify/deno.json
mise run check-versions --fix
mise run fmt
"""

[tasks."test:tooling"]
description = "Test Node.js maintenance scripts and harness utilities"
run = 'node --experimental-transform-types --test "scripts/*.test.ts" "scripts/*.test.mjs" "examples/test-examples/*.test.ts" "packages/init/src/harness.test.ts" "packages/cli/scripts/compile.test.ts" "packages/fedify/scripts/pack-skills.test.mjs" "packages/fedify/scripts/discover_tests.test.ts"'

[tasks."generate:packages-table"]
description = "Generate package tables and links for release announcements"
run = "node --experimental-strip-types scripts/generate_packages_table.ts"

[tasks.sponsors]
description = "Update sponsor lists in the supplied Markdown files"
run = "node --experimental-strip-types scripts/sponsors.ts"

[tasks."test:tooling:no-deno"]
description = "Verify Node-only tooling with Deno blocked and an empty cache"
run = "node scripts/test_tooling_no_deno.mjs"