rexxars

WhatWG/W3C compliant EventSource client for Node.js and browsers

Streaming, source-agnostic EventSource/Server-Sent Events parser

Get the auth token set for an npm registry (if any)

Hyphenates a camelcased CSS property name

Generic HTTP request library for node, browsers and workers

Tagged template literal for Sanity.io GROQ-queries

Shared TypeScript definitions for core Portable Text data structures

Portable Text Editor made in React

Toolkit of handy utility functions for dealing with Portable Text

Convert a Sanity Schema to a Portable Text Schema

Automatically transform text to typographic variants

Apply Sanity patches to a value

Write nice template literals with newlines, but format as a single-line string

Render Portable Text with React

Super-thin React wrapper for refractor (Syntax highlighting using VDOM)

Render Portable Text to HTML

Sanity.io toolkit for Next.js

Automatically match a pair of characters and decorate the text in between

Recursively resolve promises within objects

Find the latest version of an npm module matching a given semver range

React hook that triggers a callback after hot-module reloading has been performed (for any module, not just the one it was used in)

React hook for finding device pixel ratio (DPR), optionally capping/rounding

Mendoza, differ for structured documents

Convert Portable Text to and from Markdown

Create platform-aware keyboard shortcuts with automatic detection of Apple vs non-Apple platforms

React JSON inspector component

Add helpful Markdown shortcuts to the editor

Portable Text Schema

Easily configure Input Rules in the Portable Text Editor

React split-pane component

Restrict the Portable Text Editor to a single line

Convert HTML to Portable Text with built-in support for Google Docs, Word, and Notion

Allow pasting links in the Portable Text Editor

Sanity-flavored HTML to Portable Text conversion (wraps @portabletext/html)

Modern EventSource client for browsers and Node.js

POC for Sanity Design Tokens

Compute the list index of each list item for custom list rendering

Track the drop position during drag and drop for custom drop indicators

Runtime typescript and ESM support for Node.js

Tables as real Portable Text, edited with spreadsheet-grade selection

Sanity Design System POC

Expose per-command Markdown to coding agents through an oclif flag

Encodes events as well-formed EventSource/Server Sent Event (SSE) messages

Checks if two URLs pass the "same origin"-policy (RFC 6454)

The HTML5 Server-Sent events specification is introduced "to enable servers to push data to Web pages over HTTP or using dedicated server-push protocols".

Markdown fields in Sanity Studio. Supports Github flavored Markdown and image uploads.

React renderer for CommonMark (rationalized Markdown)

Generates a set of Sanity patches needed to change an item (usually a document) from one shape to another

Shared request-access screen and access-request logic for Sanity applications

A browser polyfill for W3C EventSource (http://www.w3.org/TR/eventsource/)

Check for the existence of a path in a case-sensitive manner and, if not found, suggest where it might be at

Dashboard widget for the Sanity Content Studio which displays a list of documents.

Reads a source file and extracts a sourcemap for consumption (inline or external)

List of licenses from choosealicense.com

Get the user info for the current user from git config, at the project or global scope

Secret detection library for chat and paste contexts. 1,100+ rules from TruffleHog detectors.

Utilities for building a toolbar for the Portable Text Editor

Render [Portable Text](https://portabletext.org) block content with [Svelte](https://svelte.dev/) components.

*Experimental*: Render Portable Text with React Native

Super-thin React wrapper for lowlight (Syntax highlighting using VDOM)

WASM bindings for GROQ linting and formatting (groq-lint + groq-format)

ESLint plugin for Sanity Lint - lint GROQ queries and schema definitions

Easily configure an Emoji Picker for the Portable Text Editor

Render safe JSON-LD script tags using React

GROQ linting engine, rules, and CLI for Sanity Lint

Gatsby source plugin for building websites using Sanity.io as a backend.

Shared eslint configs for sanity-io

Build typeahead pickers (emoji, mentions, slash commands) for the Portable Text Editor

Render syntax-highlighted JSON data using React. Lightweight.

Shared types and utilities for Sanity Lint

Schema linting engine and rules for Sanity Lint

Vercel AI SDK provider for Sanity Content Agent API

LaTeX input for Portable Text Editor in Sanity Studio.

A tiny framework-agnostic library that makes logos look good together

Server-Sent Events "channel" where all messages are broadcasted to all connected clients, history is maintained automatically and server attempts to keep clients alive by sending "keep-alive" packets automatically.

Connect a Portable Text Editor with a Sanity document using the SDK

Tiny Sanity client alternative should you only need to do queries

In-memory fake of @sanity/client for tests. Implements the data-plane surface (fetch / getDocument / mutate / patch / transaction / actions / releases / perspectives) against a groq-js evaluator and a closure-scoped store, with mutation-log inspection, a

React component that renders a hexagon using SVG

Express middleware for handling HTTP range requests

Shared eslint configs for Bengler

parse the .git/config file into a useful data structure

React component for allowing panning of DOM-elements too large for their container, in a Google Maps-like way.

Create a multipart/byteranges stream based on passed ranges

Serialize Portable Text to ReactPDF

Minifies GROQ-queries, removing unnecessary whitespace

Prettier plugin for formatting GROQ queries

Group a stream into chunks of a given size, then perform an async operation on each batch before proceeding, with a given concurrency

Language Server Protocol implementation for GROQ

Render Portable Text with Solid JS

An in-memory fake of `@sanity/client` for local testing. Implements the data-plane subset (queries, mutations, transactions) against a [groq-js](https://github.com/sanity-io/groq-js) evaluator and a closure-scoped document store. Created fresh per test —

Measure and compare ESM bundle scenarios with Rolldown

Renders Commonmark/Markdown as React components

Create modern favicon variations from source image

Encrypts data for use in your travis-ci yml configuration file

This package transforms data of the RichText type (used by Contentful) into a data structure representing the same content in Portable Text.

Splats a bunch of project configs/defaults to a folder

Testing utilities for the Portable Text Editor

Render Portable Text with Astro

Set of higher-order components to turn any list into a sortable, touch-friendly, animated list

[DEPRECATED] Use @sanity/vision instead

Promise-based utility to make sure you don’t call rate-limited APIs too quickly.

Mock of a private npm registry, useful for testing npm-related stuff

Example dashboard widget for Sanity Content Studio

Backend plugin for the Socket.dev security integration. This plugin provides a REST API for fetching Socket.dev security reports with server-side caching.

ESLint configuration for VG.no coding standard

Extracts information on products, categories and stores from Vinmonopolet

A Backstage plugin that integrates with Socket Security to display security findings and vulnerability analysis for repositories.

VG.no coding standards

On-the-fly image transforming service, utilizing libvips for performant image operations

Shows open GitHub secret-scanning alerts for an entity's repository.

deploy to gh-pages with one command

Checks whole sentences / chunks of text for errors and returns positions and suggestions for each

Sanity SDK integration layer for @sanity-labs/react-table-kit.

Serves GitHub secret-scanning alerts to Backstage, sliced per repository.

Composable React table components and helpers for Sanity-flavored editorial UIs.

React hooks and action APIs for Sanity Labs tasks.

VaffelNinja ESLint configuration

Inlines JSON file imports straight into JS code

React hooks and action APIs for Sanity Labs comments.

Shared addon dataset runtime context for Sanity Labs SDK feature packages.

Render a ProseMirror document using React components

AI coding agent with continuous memory - infinite context across sessions

Renders a chess board using React

Helpers and type definitions for binding Sanity resources

Enhanced Sanity.io plugin development experience

Brand-locked PowerPoint generation for LLMs. Write a slide template in React; Claude (or any MCP client) writes the deck through the bundled MCP server without drifting on fonts, colors, or layout.

Add custom npm registry + user credentials to npmrc based on environment variables or CLI options

Dashboard widget for Sanity Content Studio

Count number of lines in a file or stream

Generate a GraphQL API based on your SQL database structure

Sanity.io source for Gridsome

MCP server for AI-powered image analysis - describe, detect objects, analyze colors

Browser MCP - Web browsing tools for AI agents

Audio production for video. Track-based, markdown-driven, Remotion-ready.

An Imbo client for node.js and modern browsers

Sanity Studio plugin for using Cloudinary to select images from

Mead source adapter that fetches lower-resolution versions from GCS (generated by nectar)

This library emulates ioredis by performing all operations in-memory.

A dev tool for inspecting and testing Sanity Agent Contexts. It runs a small server and web UI where you can chat with your agent, see tool calls and token usage, and tweak system prompts and runtime options.

Splits OpenVPN (.ovpn) files into separate files for private key, user+ca certificates and tls-auth key, for use with network-manager in debian/ubuntu

Tools for working with Codename Eagle game

Transform hast to portable text

Sanity App SDK adapter hooks for [`@sanity-labs/workflow-engine-explore`](https://www.npmjs.com/package/@sanity-labs/workflow-engine-explore). Wires `useClient` + `useCurrentUser` from `@sanity/sdk-react` into the engine's call signatures so consumers don

Leaflet geopoint input component for Sanity.io

A workflow / BPM engine for Sanity content. Defines workflows as data, runs them as instances against a Sanity client, gates actions on guards, queues effects for runtimes to drain.

Google Cloud Storage source for the Mead image transformer service

Caches the result of transformations. Pluggable storage implementation.

Org-free stdio MCP facade for the Sanity Canvas CRUD API. Resolves the user's Canvas resource from a bearer token and forwards JSON-RPC to the per-resource HTTP MCP. Run via `npx @sanity-labs/canvas-mcp-bridge`.

Check if a hostname or URL resolves to a private IP address

React component for "packing" elements together in a pinterest-like layout

Example dashboard widget for Sanity Content Studio

Alternative version of postcss-simple-vars that supports asynchronous loading of variables

An Imbo client for node.js and recent browsers

In-memory test bench (`createBench`) for [`@sanity-labs/workflow-engine-explore`](https://www.npmjs.com/package/@sanity-labs/workflow-engine-explore). Wraps the engine and a [test-client](https://www.npmjs.com/package/@sanity-labs/workflow-engine-explore-

A typescript compiler for gulp with incremental compilation support.

Connect your own infrastructure to Miriad

Replace default spinners with NYANCAT SPINNERS OMG

Update a DNS record on CloudFlare with a new IP

Client for the Mead image service

Beautiful ascii doge, as string or array

Returns a `stream.Readable` from a URI string

Decorate callsites with methods that return the sourcemapped file/line/column locations

Gleipnir module that asserts exchanges, queues and bindings

Declare a Sanity schema using GraphQL SDL syntax

Sanity plugin for debugging roles and plugins

A personal card for Espen Hovlandsdal (@rexxars)

Sanity Design System POC

Convenience wrapper for node amqplib

http(s) proxy source for the Mead image transformer service

A Node.js BLE (Bluetooth Low Energy) central library.

Flat-file markdown content/blog system

Update the IP of a Dynamic DNS domain on Namecheap

Simple module for generating 1bit bar charts

Microservice that scrapes websites, extracting key information such as title, description, opengraph information etc

Convert tumblr blog entries to prosemirror format

Sanity Studio plugin for rendering various previews

Filesystem source for the Mead image transformer service

Middleware for express & hapi, automatically instrumenting node applications for prometheus

Small(ish) listener implementation for Sanity

Tiny GraphQL request library for Sanity

Gleipnir module that manages publishing of messages

Debug npm `create` commands (well, understand them)

Fetches soccer stream info from soccerstreams.net

S3 source for the Mead image transformer service

LevelDB storage adapter for SSE Hub backend

Extract supermark properties from a markdown file

Redis storage adapter for SSE Hub backend

Doge meme generator provided as a Sanity asset source plugin

package for testing NPM stuff. Don't use unless you know what it does,

Logs a message to users if callback has not been called within given time

Module exposing a number of different `exports` fields, for testing which one your bundler/environment ends up using

W3C compliant EventSource client for Node.js and browser (polyfill)

Web folder source for the Mead image transformer service

Refreshes the current user session in Sanity studios on an interval

Calculates estimate(s) based on the PERT method by using "most likely time", "optimistic time", and "pessimistic time"

unpack rsa fields from PEM strings (typescript/browser-compatible fork)

Super-simple source resolver, that simply uses the configuration file

Print the configured npm registry URL for a given scope

Build-time dependency indirection in the style of the Sanity v2 parts system

Extracts git logs from repositories

Mead plugin that verifies signed URLs using MD5

Zipkin instrumentation middleware for get-it

Watches and compiles LESS-files, calls callback on change

Creates 1-bit GIF-images from an ndarray of bits

Reads a CSS file meant for 'global context' and prefixes each selector with a specified selector, wrapping the remainder in :global()

Simple (probably stupid) encryption/decryption for browsers and node

Fetch the npm packages a user is a maintainer of and figure out which of them (if any) are considered high-impact

VaffelNinja coding standard

Converts one or more images to a given aspect ratio by cropping

Prints 2D-arrays of bits. Supports ndarray.

A simple and beautiful text diff viewer component made with diff and React

Blazing fast .d.ts modules for libraries

Easy to use universal dynamic routes for Next.js

Generates a set of Sanity patches by comparing two JSON structures

Dumps env vars, process.argv and similar to the console

Face detector plugin to be used with Imbo

Resolver for Sanity roles that works with eslint-plugin-import

Readable and writable stream that spell checks your text and parses aspell output to an understandable format

A Bunyan stream for pushing messages using pushover

Emit `ETIMEDOUT` or `ESOCKETTIMEDOUT` when ClientRequest is hanged

Determines whether the second geometry is completely within the first geometry.

Sanity's Runtime CLI for Blueprints and Functions

Simple Sanity tool giving access to dead-simple user-specific notes

rehype plugin to transform to portable text

Monitors a Windward server and notifies a slack channel when someone enters or exits the game

Parses article HTML from DrPublish/DrLib into JSON-representable entities

List and update DNS records through Vercels API

Play commentary tracks from Javascript (node and browsers)

Referring documents list plugin

Super simple blog built with Supermark

Run Resonance audience tests from a Sanity Studio document inspector.