Official plugin library

Meta-Framework for Modern JavaScript Applications

Nested plugin group for cordis

Hot Module Replacement Plugin for Cordis

Include files in cordis configurations

Plugin loader for cordis

Console logger exporter for cordis

Timer service for cordis

Model-facing ask_user_question tool over the ctx.userInteraction seam

Model-facing bash tool with optional generic background-task and sandbox-escalation support

Model-facing owner-scoped persistent Bash tool backed by the Harness PTY service

Tool-call timeout policy: a tools/execute wrapper that arms a per-tool deadline on exec.signal and returns TOOL_TIMEOUT when it wins

Self-referential cordis toolset: inspect the live runtime, mount and dispose model-written plugins

Model-facing filesystem tools (read, write, edit) over the DeepSeek Harness filesystem seam (ctx.fs)

Model-facing filesystem discovery tools (glob, grep) backed by the packaged ripgrep binary (@vscode/ripgrep)

Model-facing same-session goal tools with execution-time authority checks

Model-facing background job control tools (job_output, job_list, job_kill) over the ctx.jobs registry

Model-facing lsp tool over the DeepSeek Harness LSP capability seam (ctx.lsp) — one read-only tool with goToDefinition/findReferences/goToImplementation/hover operations, one-based UTF-16 cursor coordinates, bounded location rendering, and hover normaliza

Explicit workspace file delivery declarations for the DeepSeek Harness

Model-facing pwsh tool over the bash executor seam

Model-facing owner-scoped persistent PowerShell tool backed by the Harness PTY service

Model-facing fresh-agent Ralph loop over the workflow and subagent seams

Workspace-authorized model-facing session history search, trace, and event read tools

Model-facing skill loading tool for the DeepSeek Harness

Model-facing view, create, literal replace, and line insert tool over the Harness filesystem service

Model-facing subagent delegation tool over the ctx.subagents seam

Globally named send_message, interrupt_agent, and list_agents tools over ctx.subagents continuations

Child-scoped report tool over ctx.subagents continuations

Six model-facing persistent PTY tools with owner isolation and generic background-job integration

Model-facing todo_write tool over the DeepSeek Harness event-sourced session log

Model-facing web tools (web_search, web_fetch) over the DeepSeek Harness web capability seam (ctx.web)

Model-facing workflow tool: run a JavaScript orchestration script over ctx.workflows

Provider-neutral LLM service interface for the DeepSeek Harness

DeepSeek chat-completions adapter for the DeepSeek Harness LLM seam

pi-ai-backed DeepSeek adapter for the DeepSeek Harness LLM seam (design-verification twin of dsh-llm-deepseek)

Replay LLM plugin: short-circuits llm/stream with model chunks reconstructed from a recorded session JSONL (keyless snapshot tests)

Provider-routed LLM request retry policy for the DeepSeek Harness

Sandbox-consuming implementation of the DeepSeek Harness bash executor seam (confines every command via ctx.sandbox, reports denial/enforcement result facts)

Sandbox-enforcing implementation of the DeepSeek Harness filesystem seam: fences write/edit by the per-call sandbox mode (read-only denies mutation, workspace-write contains it to the workspace + temp roots) while reads pass through

Sandbox-consuming implementation of the DeepSeek Harness PowerShell executor seam (confines every command via ctx.sandbox, reports denial/enforcement result facts)

Abstract process-sandbox seam (ctx.sandbox) for the DeepSeek Harness: same-world confinement vocabulary and the SandboxProvider contract

Local process-sandbox backends for the DeepSeek Harness sandbox seam: bwrap, the npm-distributed landlock-run launcher, macOS Seatbelt, or the Windows ACL restricted-token runner — functionally probed, fail-closed

Per-call sandbox policy resolver and current model context: deployment fallbacks plus each session's mode and workspace root, shared by every enforcing capability family

Windows ACL write-restriction sandbox backend (restricted-token spawn with orphan-SID write allowlist) for the DeepSeek Harness sandbox seam

Tool-independent managed DSH_* shell environment registry

Agent skill provider registry for the DeepSeek Harness

Bundled dsh badge skill provider for DeepSeek Harness

Local filesystem skill provider for the DeepSeek Harness

Abstract compaction service seam (ctx.compaction) for the DeepSeek Harness

Token-meter-driven compaction policy and LLM summarization backend for the DeepSeek Harness

Replay-safe model-free head/middle/tail pruning for tool-result surface nodes

Event-sourced session store for the DeepSeek Harness

Semantic session durability checkpoints before model requests and tool side effects

Streaming adjacent Session format migration machinery

Build-static first-party Session format codec and migration catalog

Frozen released-v0 Session codec and identity migration to v1

Frozen released-v1 Session codec and assistant-stream migration to v2

Streaming system-prompt, canonical-envelope and PTC migration into V3

Incremental lossless session-log request extension for the official DeepSeek LLM API

Web Session-log export command and shared download dialog

Abstract durable session persistence seam (ctx.sessionPersistence) for the DeepSeek Harness

JSONL durable session persistence backend for the DeepSeek Harness

SQLite durable session persistence backend for the DeepSeek Harness

Session-projection seam: the merge-extensible projection type table, the provider contract, and the ctx.sessionProjections registry serving whole current values of log-derived per-session state

Persisted projection cache (ctx.sessionProjectionCache): durable per-session projection checkpoints over the domain data form, throttled write-behind, and the cold-read ladder (cache row + persistence tail replay)

Combined session query service contract with concrete reads, traces, and filters

Concrete ctx.sessionQuery backend with SQLite FTS5 search

Cross-session snapshot references and durable untrusted model context (ctx.sessionReferences)

Session-log snapshot core with an ACP protocol adapter, expected-output normalization, and fixture invariants

Whole-log conversation counts and wall times projection (sessionStats) for the DeepSeek Harness

Telemetry seam for the DeepSeek Harness: session-event capture, projection, redaction, and handoff to a reporting backend

OpenTelemetry backend for the DeepSeek Harness telemetry seam: hands captured session records to the OTel JS SDK's log pipeline

Log-backed session title service and provider registry for the DeepSeek Harness

All-user-messages LLM provider plugin for DeepSeek Harness session titles

First-message LLM provider plugin for DeepSeek Harness session titles

Shared LLM generation policy for DeepSeek Harness session-title providers

Whole-log turn outline projection (turnOutline) for the DeepSeek Harness

Durable immutable attachment storage seam for the DeepSeek Harness

Private content-addressed DSH_HOME attachment storage

Abstract filesystem capability seam (ctx.fs) for the DeepSeek Harness — vocabulary types, the FileSystem service (text IO + optional version-guarded atomic mutations), and the fs/* policy event vocabulary

E2B filesystem implementation for DeepSeek Harness

Local-filesystem implementation of the DeepSeek Harness filesystem seam (ctx.fs)

File-context policy plugin for the DeepSeek Harness — observed-state, read-before-edit, and version-guarded write/edit added over the ctx.fs provider seam through the fs/* event gate (no service API)

Abstract spill storage seam (ctx.spillStore) for the DeepSeek Harness — save oversized tool text and return a retrieval locator

Local-filesystem implementation of the DeepSeek Harness spill storage seam (private session-scoped files)

Tool-result spill policy for the DeepSeek Harness — replaces oversized plain-text tool results with a retained preview plus a spill-file path (no service surface)

Storage hub (ctx.storage): named backend registry plus mounted data-form facilities for the DeepSeek Harness

Domain data form (ctx.storage.domain): schema-validated, event-emitting KV domains over storage backends for the DeepSeek Harness

JSON file KV storage backend for the DeepSeek Harness storage hub

SQLite storage backend (kv facet) for the DeepSeek Harness storage hub

Agent interface, registry, initiator scope, and event vocabulary for the DeepSeek Harness

Default model selection shared by Agent entry points

Workspace context loader for AGENTS.md/CLAUDE.md instruction files

The concrete agent loop plugin for the DeepSeek Harness

Shared prerequisite mounting for tests that exercise the concrete agent loop

Per-session agent composition from preset cordis.yml files for the DeepSeek Harness

The default executor-less/UI-less agent spine with fallback session titles, provider-routed retry, and optional persisted goals

Agent-plane presentation selector: composes one agent's tools as Code Mode, native, or both

Durable workflow-run Conversation Node and nested member disclosure for dsh web

Event-sourced same-session goal state and lifecycle service for the DeepSeek Harness

Race-fenced same-session goal-round driver

Background job registry (ctx.jobs) for the DeepSeek Harness — shared ids, owner isolation, polling, cancellation, and completion listeners for long-running tool work

Process-local implementation of the DeepSeek Harness background job registry seam

Logged per-agent plan mode with deployment guidance, a direct slash command, and a user-reviewed exit

Agent-scoped durable after, at, and fixed-rate reminders over the session event log

Abstract subagent seam (ctx.subagents): named-provider registry for delegating to child agents

Out-of-process ACP subagent backend: drives a child agent in a spawned subprocess over the Agent Client Protocol

One-shot Claude Code subagent provider over the official Agent SDK

One-shot Codex subagent provider over the official app-server protocol

Out-of-process SDK subagent backend: drives a child DeepSeek Harness runtime subprocess over stdio JSON-RPC through the TypeScript SDK client

In-process fork subagent backend: runs a child agent seeded with a prefix of the parent's log

Shared in-process subagent run driver: drives a child agent on ctx.agents (used by the spawn and fork backends)

In-process spawn subagent backend: runs a fresh child agent on ctx.agents

Workflow capability seam: ctx.workflows service, run vocabulary, and workflow/* events

worker-thread workflow engine: executes model-written orchestration scripts off the host event loop, bridging agent() calls back to ctx.subagents

Wire consumer layer: HTTP-up/WebSocket-down client, ConnectionController dual streams with reconnect, and fixture api

Agent-scoped browser file upload, streaming intake, and staged receipt service

Dev-only hot-reload driver for script-loaded client entries: SSE rebuilt frames → invalidate/prefetch → fiber swap through the vendored Loader entry

Locale plugin: Host-backed zh/en preference, browser-derived fallback, locale snapshots, and typed namespace dictionaries

Client module system, dual-face: node half composes the __DSH_BOOT__ entry graph (incremental dsh.client scan, bundle route, index tap, webPlugins service); browser half is the lazy-CJS module table the vendored cordis Loader consumes as its internal seam

Unified client resource model: protocol-registered providers turn URL addresses into live values, consumed through the useResource global standard hook

Client core services: SlotsService, SessionsService (scope tree + object layer)

Schema/draft model layer for settings editors: rehydrates a serialized schemastery schema, validates drafts, and edits them immutably by path

React-free observable and snapshot-store contracts with the shared Zustand/Immer engine

jsdom slot test runtime: real Cordis Context + SlotsService + web-react renderer with test-owned session/workspace doubles for feature specs

Agent-preset surfaces: the default for later sessions, this session's seat, and the composition editor

Approval composer takeover over the scoped Remote Event waterfall

Pure React attachment atoms for the dsh web UI: draft-image rail, message image gallery, and original-image lightbox (zero cordis)

Official DeepSeek Harness brand occupants for the Web client's sidebar and conversation Hero slots

Chat Conversation target, node definitions, renderers, and details surface

Client command surface: global directory cache, '/' source, three command UI kinds, popupSelect registry

Conversation domain: skeleton, ordered chat flow, composer with the Host-backed busy-Enter preference, and details host

Cordis dynamic-plugin definition card: the keyed cordis_define tool row with its run/stop switch

Produced-files turn tail: the deliverables row a finished turn ends with

In-app directory browsing surface: the workspace directory-flow owner rendering the host's listing and creation primitives

Native directory-picker surface: the renderless workspace directory-flow occupant driving the host's OS chooser

Docking layout kit: split-tree engine with invertible operations, and the React components that render and drive it (zero cordis)

Session goal surface: GoalBar docked above the composer, read from the goal session projection

Input trigger pipeline: '/' and '@' detection, candidate menu, pick routing to registered sources

Session-header background-job list: live registry state mirrored from session/jobs frames

Shell plugin: three-column AppFrame with drag handles, ctx.layout viewing-state service (navigation + panels)

Per-message feedback controls contributed to the assistant-message action strip, backed by the messageFeedback Host Remote

Model selection: the /model popupSelect over session.models / session.selectModel

Web Session-header "Open In..." split button opening the session workspace directory in a locally installed application

Permission surfaces: a new-session default in General settings and a current-session /permission popup over the permissions projection

Plan-mode composer control: the conversation.input.plan seat over the plan projection and the /plan command channel

Pure React atoms for the dsh web UI: controls, icons, markdown, and JSON inspectors (zero cordis)

Unified Web @file and @session reference source

Browser UI renderer: React slot bindings, ctx.uiRenderer, and the assembled application root

Read-only active Schedule catalog in the Web Session header

Session Controller adapter for React and session-scoped slots

Settings shell plugin: sidebar trigger, modal panel, feature sections, and an ordered full-page onboarding stage

Settings ownerless-copy and product onboarding plugin: the General section, shell trigger/header chrome content, settings dictionaries, and the versioned welcome notice

Models settings and official-DeepSeek first-run routing over one live provider/settings/credential join

Plugins settings section with feature-owned tabs and configurable host-plane plugin cards

Sidebar plugin: session multi-level tree, search, grouping, state dots

Extensible document previews for Sidebar files: Markdown, highlighted code, images, PDF, HTML, and plain text

Workspace file tree tab type for the right Sidebar: lazy directory listing over the workspaceFiles Remote namespace, opening files into the Sidebar

Right Sidebar: the docking surface's session-bound state, its panel and header expand control, and the navigation service over it

Text preview tab type for the right Sidebar: the fallback viewer for file: addresses, drawn from the file resource with line navigation, wrap, and reload

Web skill references and the dedicated skill tool row

Slot registry pure core: SlotMap declaration merging, single register composition API, four-share props types, store-seat types, renderer install seam

Subagent conversation catalog, continuation routing UI, and '@' reference source

Theme plugin: ThemeService (light/dark/system preference, prefers-color-scheme resolution, theme/change snapshots; no DOM), --dsw-* token base stylesheets; registers the Appearance settings row

Client Tool call-tree renderer and keyed per-tool presentation slot

Trajectory event ledger with an interactive timing overview: pure-consumer plugin registering into the conversation ViewMap (no service)

Web ask_user_question feature: host tool mount plus composer-takeover question UI

Workspace picker plugin: one WorkspacePicker registered into the sidebar and empty-state workspace slots

Web shell kernel: bootWebShell (module system holding + seed table + two-stage boot + AppRoot gate + app-shell assembly entry), consumed by the apps/web vite entry

Shell-side React glue: createSlotRenderer, SessionProvider, bindSnapshotSelector (uSES bridge), useInvoke

SPA dist server for the Web shell: owns the webserver fallback seat, serving the built frontend with index-tap injection, traversal rejection, and SPA index fallback

Persistent PTY session seam for the DeepSeek Harness — owner-scoped ids, backend registry, interactive sends, reads, signals, and awaited cleanup

Persistent shell PTY backend over the DeepSeek Harness subprocess terminal primitive

Abstract web access capability seam (ctx.web) for the DeepSeek Harness — search/fetch provider registry, registration-order-independent selection, request/result vocabulary, and the WebError taxonomy

The dsh browser-surface bundle: the web patch layer over dsh-base plus the runtime glue plugin (frontend dist serving, web-surface prompt, bash runtime variables, URL line)

Anonymous public HTTP(S) fetch provider for the DeepSeek Harness web capability seam (ctx.web)

Web application entry: vite build over the @deepseek-ai/dsh-client-web shell library; dist/ served by apps/cli's dsh web

DeepSeek-backed search provider (native web_search via the Anthropic-compatible API) for the DeepSeek Harness web capability seam (ctx.web)

Exa-backed search provider for the DeepSeek Harness web capability seam (ctx.web)

Perplexity-backed search provider for the DeepSeek Harness web capability seam (ctx.web)

Fire-and-forget webhook rule runtime that creates Workspace-backed DeepSeek Harness Sessions

Signed GitHub HTTP webhook adapter for the DeepSeek Harness webhook runtime

Automation-only Agent Client Protocol server for driving DeepSeek Harness agents over JSON-RPC stdio

The dsh ACP profile bundle: automation-only JSON-RPC stdio and process lifecycle over dsh-base

ACP automation server app: agent spine + JSONL persistence + ACP transport, with a JSON-RPC stdio bin

ACP test kit: shared subprocess launcher, snapshot scenario harness, expected-output normalizers, and suite factory

Bridge plugin: run a Claude Code hooks.json / settings hook config on the DeepSeek Harness interception seams

Bridge plugin: run a Codex hooks.json hook config on the DeepSeek Harness interception seams

Abstract LSP capability seam (ctx.lsp) for the DeepSeek Harness — language-server provider registry keyed by branded id and extension mapping, order-independent per-query selection, normalized definition/references/implementation/hover requests and result

Generic stdio language-server provider for the DeepSeek Harness LSP capability seam (ctx.lsp) — spawns configured servers, translates JSON-RPC, and serves transient-open goToDefinition/findReferences/goToImplementation/hover queries in the host filesystem

MCP client bridge: connects to MCP servers and registers their tools on ctx.tools

Shared boot glue for the app bins: .env loading, fail-loud Loader guards, snapshot-aware config resolution, and the Loader boot sequence

Immutable command-line handoff from a dsh launcher to any app plugin that injects cmdlineArgs

The dsh one-shot bundle: a direct core Agent/Session runner over dsh-base with no Host, HTTP, or browser layer

The dsh SDK profile bundle: stdio JSON-RPC serving and process lifecycle over dsh-base

TypeScript client SDK for driving a DeepSeek Harness runtime subprocess over stdio JSON-RPC: the DeepSeekHarness high-level turns API and the lower-level HarnessClient

Bin that boots an external Cordis config for the stdio JSON-RPC SDK runtime

Stdio JSON-RPC server plugin for out-of-process DeepSeek Harness SDK clients

The standalone minimal SDK profile bundle: JSON-RPC, one DeepSeek adapter, persistent shell, editor, and JSONL sessions

Shared wire protocol for the DeepSeek Harness SDK runtime: the newline-delimited JSON-RPC stdio transport and the named request, result, and notification types spoken between the runtime server and SDK clients

dsh CLI: profile boot, plugin management, and the browser UI alias

Shared anonymous user identity for DeepSeek Harness telemetry and feedback correlation

TypeRT Remote Host dispatcher and Client API endpoint

Remote BFF assembly and Host Agent/Session lookup policy

Session Remote commands, cold reads, and live control transport

Remote owner for the configuration surfaces over the settings-domain seams

Workspace Remote commands and reconnect-safe state transport

Workspace file service and Client resource provider: bounded reads, directory listing, and live metadata over the workspaceFiles Remote namespace

Zero-dependency atomic file replacement: exclusive-create random-suffix temp + rename carrying the caller-stated permissions (writeFileAtomic)

Authorization seam (ctx.authorization): plugin-owned flows that obtain a credential through a conversation with the human

The shared dsh core as a profile bundle: every profile's first patch layer, inserting the base plugin rows over the empty profile root

Local-subprocess implementation of the DeepSeek Harness bash executor seam

Type-only Branded<B> nominal-typing primitive for the DeepSeek Harness

Persistent append-only chunked lists with bounded copying and JSON checkpoint validation

Abstract code-execution seam (ctx.codeRuntime) for the DeepSeek Harness

CPython subprocess implementation of the DeepSeek Harness code-execution seam

Worker-thread implementation of the DeepSeek Harness code-execution seam

Human-facing slash command for explicit session compaction

Log-only session feedback producer and human-facing slash command

Human-facing slash command for persisted same-session goals

Plugin-owned human command registry for DeepSeek Harness UI surfaces

Browser half of dynamic dual-half plugin packages: event subscription, closure evaluation, guard facade, and loader entries

Dynamic package definition registry, host-half sandbox lifecycle, and invoke handler table for model-mounted dual-half packages

Abstract credential seam (ctx.credentials): settings carry references to secrets, providers own the values

File-backed credentials provider ($DSH_HOME/.env under the live process environment) for the DeepSeek Harness

Additive request-field registry for the official DeepSeek LLM API adapter

Zero-dependency circular deque with amortized constant-time end operations and bounded vacant storage

Shared E2B sandbox lifecycle for DeepSeek Harness provider adapters

Implicit-root Agent Teams roster, durable peer mailbox, and shared task DAG

Experimental profile bundle enabling Agent Teams over dsh-base

Experimental Web profile layer for Agent Teams Remote and UI plugins

Web Agent Teams roster, task board, and teammate navigation

Scoped model-facing Agent Teams tools over ctx.agentTeams

File-reference discovery contract and shared @file grammar

Local-filesystem ctx.fileReferences provider with bounded fuzzy indexes

Shared filesystem path helpers for the DeepSeek Harness

Shared Claude Code / Codex hook wire protocol: matcher engine, stdin/exit-code/stdout codec, multi-hook merge, and hook/* session events

API gateway: the ApiProxy contract (api/), the fetch carrier pair (fetch/), and the host-side gateway plugin providing ctx.apiProxy

Abstract workspace-directory picking seam (ctx.directoryPicker) for the DeepSeek Harness web GUI host

Adaptive chooser of the directory-picker seam: resolves the host situation at boot and mounts the native or browse backend for the DeepSeek Harness web GUI host

In-app browsing backend of the directory-picker seam (listing/creation primitives over the host filesystem)

Native-OS-chooser backend of the directory-picker seam for the DeepSeek Harness web GUI host

Host half of open-in-app: resolved application catalog, icons, and the launch endpoint as three webServer routes

Web route-registration plugin: HTTP and upgrade routes, index transform taps, and static dist fallback; knows no harness concepts

Process-wide outbound HTTP proxy policy for DeepSeek Harness: resolve it from the launch environment and install it as undici's global dispatcher

Registry service for package-owned DeepSeek Harness runtime invariants

Immutable DeepSeek Harness launch environment that records which layer supplied each value

Lifecycle-bound per-message rating and note sidecar for the DeepSeek Harness

Zero-dependency no-shell execFile runner for host-native OS integrations: utf8 stdio capture, abort propagation, Windows hide

Zero-dependency bounded-retention primitive: ItemRetainer/TextRetainer + neutral notice helpers (what did we keep, what did we omit)

Shared type declarations for package.json.dsh configuration fields

User-facing permission presets (ctx.permissionPresets) for the DeepSeek Harness: one product-level Permissions select bundling the sandbox-mode and approval-policy knobs, written through to their own session events

Composition-authored deployment persona section for the DeepSeek Harness

Active Loader-backed plugin package inventory for official DeepSeek LLM API requests

Local PowerShell implementation of the DeepSeek Harness bash executor seam

Repeat-tool-call guard plugin: advisory reminders when an agent loops on identical tool calls

Scoped-context registration primitive (scope tags, scope-filtered event dispatch) for the DeepSeek Harness

Abstract user-settings seam (ctx.settings) for the DeepSeek Harness

File-backed settings provider (settings.yaml) for the DeepSeek Harness

Abstract bash executor seam (ctx.shell) for the DeepSeek Harness

Subprocess seam (ctx.subprocess) for the DeepSeek Harness — managed process groups, bounded spill-backed output, and escalated kills behind one abstract service

E2B subprocess implementation for DeepSeek Harness

Local-subprocess implementation of the DeepSeek Harness subprocess seam

System prompt assembly registry for the DeepSeek Harness

Opt-in durable per-step context with the current time and elapsed time

Zero-dependency timeout/deadline primitive: clampTimeout, deadline, timeoutOf, TimeoutReason (timing + classification only, no termination)

Opt-in durable per-step context with this agent's tmux pane and window location

Replay-aware token measurement service (ctx.tokenMeter) for the DeepSeek Harness

Tool registry and execution pipeline for the DeepSeek Harness

TypeScript project analyzer and model-driven Typert artifact generator

Loader integration for generated Typert package contributions

Compiler-independent Remote metadata and Typert provider protocols

Runtime registry for generated package reflection and Zod schemas

User-approval seam (ctx.approval) for the DeepSeek Harness: one-shot permission decisions dispatched to composed answerers over the approval/request waterfall, fail-closed by default

Abstract user-questions seam (ctx.userQuestions) for asking the human during agent runs

Zero-dependency browser-safe UUID and byte-encoding helpers

Zero-dependency time vocabulary shared by wire boundaries: canonicalClientTimeZone (IANA zone validation and canonicalization only, no formatting)

Duplicate-install-safe value primitives for the DeepSeek Harness

Browser-safe Workspace path and display helpers

Low-level Win32 process, stdio, and Job Object primitives for the DeepSeek Harness Windows sandbox

Workspace entity registry (ctx.workspace): durable workspace records with validated session attachment over the domain data form for the DeepSeek Harness

A collection of common utilities

Landlock self-restrict-then-exec launcher for sandboxing subprocesses on Linux: per-platform prebuilt static binaries plus the JS seam that resolves, probes, and speaks their CLI contract

Prebuilt landlock-run Landlock launcher binary for linux-arm64 (static musl) — resolved as a file path by @deepseek-ai/node-addon-landlock-run, never imported

Prebuilt landlock-run Landlock launcher binary for linux-x64 (static musl) — resolved as a file path by @deepseek-ai/node-addon-landlock-run, never imported

Prebuilt system primitives: a Linux Landlock launcher and asynchronous POSIX flock through stable Node-API

Prebuilt POSIX flock Node-API binding for macOS arm64

Prebuilt POSIX flock Node-API binding for macOS x64

Linux arm64 system binaries: static Landlock launcher and glibc/musl Node-API flock addons

Linux x64 system binaries: static Landlock launcher and glibc/musl Node-API flock addons

Type driven schema validator