Add local npm registry publish and install

2026-10-16 23:08:20 +11:00
15 changed files with 567 additions and 633 deletions
@@ -261,27 +261,6 @@ there's nothing to provision. To bring your own key instead, point
 `TF_SIGNING_KEY_PASSPHRASE`), which takes precedence over the generated one.
 `TF_PROVIDER_PROTOCOLS` (default `5.0,6.0`) sets the advertised plugin protocols.

-### Local Go module proxy
-
-A local `goproxy` repo serves private modules over the GOPROXY protocol
-(`@v/list`, `@latest`, `@v/<ver>.info|.mod|.zip`). Publish a version by
-uploading its files under the case-encoded module path (uppercase as `!lower`):
-
-```sh
-for ext in zip mod info; do
-  curl -fsSL --upload-file v0.1.0.$ext \
-    https://artifactapi.k8s.syd1.au.unkin.net/api/v2/remotes/go-internal/files/example.unkin.net/hello/@v/v0.1.0.$ext
-done
-GOPROXY=https://artifactapi.k8s.syd1.au.unkin.net/api/v1/local/go-internal,https://proxy.golang.org,direct \
-GONOSUMDB=example.unkin.net go get example.unkin.net/hello@latest
-```
-
-Build the zip with `golang.org/x/mod/zip` or reuse the files `go mod download`
-leaves in `$(go env GOMODCACHE)/cache/download`. Uploads are validated: zips must
-pass `zip.CheckZip` (every file under `module@version/`), `.mod` must declare the
-module, and `.info` must match the version. `.info` is optional; it is
-synthesized from the version when absent. `@v/list` lists versions with a `.mod`.
-
 ### Local docker registry

 A local `docker` repo is a real container registry, not a mirror: it serves the
@@ -300,6 +279,20 @@ content-addressable store (deduplicated by digest, reaped by GC once
 unreferenced); tags are mutable references and re-pushing a tag moves it. Blob
 uploads support both the monolithic and chunked (`POST`/`PATCH`/`PUT`) flows.

+### Local npm registry
+
+A local `npm` repo is a real npm registry: `npm publish` (scoped and unscoped)
+and `npm install` work against `/api/v1/local/{name}/`. npm requires an
+`_authToken` for the registry before it will publish; any value works.
+
+```ini
+# .npmrc
+registry=https://artifactapi.k8s.syd1.au.unkin.net/api/v1/local/npm-internal/
+//artifactapi.k8s.syd1.au.unkin.net/api/v1/local/npm-internal/:_authToken=unused
+```
+
+Versions are immutable; dist-tags sent with a publish move to that version.
+
 ## Access Control

 | Field | Default | Behaviour |
@@ -318,6 +311,7 @@ No patterns + no blocklist = open proxy. Provider handles mutability classificat
 ```
 GET /api/v1/remote/{name}/{path}     Proxy/cache artifact
 GET /api/v1/virtual/{name}/{path}    Virtual repo (merged index)
+PUT /api/v1/local/{name}/{package}   npm publish (local npm repos)
 GET /v2/{name}/{path}                Docker Registry v2
 ```

@@ -27,7 +27,9 @@ already-running stack.
  mock upstream: first fetch `X-Artifact-Source: remote`, second `cache`, bytes
  verified against the origin fixture.
 - **Local uploads** — generic (upload/download), pypi (wheel + generated `simple/`
-  index), rpm (real package + **automatic repodata** generation).
+  index), rpm (real package + **automatic repodata** generation), npm (stock
+  `node:22` client: `npm publish` unscoped + scoped, `npm install` + `require()`,
+  second version, republish rejected).
 - **Virtual repositories** — pypi simple-index merge and helm `index.yaml` merge
  across two members.
 - **Mirrorlist** — an rpm remote with a `mirrorlist` of extra upstream mirrors
@@ -1,57 +0,0 @@
-//go:build dockere2e
-
-package e2edocker
-
-import (
-	"bytes"
-	"net/http"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"golang.org/x/mod/module"
-	modzip "golang.org/x/mod/zip"
-)
-
-// TestLocalGoProxy publishes two module versions and reads them back over the
-// GOPROXY protocol.
-func TestLocalGoProxy(t *testing.T) {
-	createRepo(t, `{"name":"local-go","package_type":"goproxy","repo_type":"local"}`)
-	defer deleteRepo(t, "local-go")
-
-	const mod = "example.unkin.net/!hello"
-	gomod := []byte("module example.unkin.net/Hello\n\ngo 1.25\n")
-	var zip010 []byte
-	for _, ver := range []string{"v0.1.0", "v0.2.0"} {
-		dir := t.TempDir()
-		os.WriteFile(filepath.Join(dir, "go.mod"), gomod, 0o600)
-		os.WriteFile(filepath.Join(dir, "hello.go"), []byte("package hello\n"), 0o600)
-		var buf bytes.Buffer
-		if err := modzip.CreateFromDir(&buf, module.Version{Path: "example.unkin.net/Hello", Version: ver}, dir); err != nil {
-			t.Fatal(err)
-		}
-		if ver == "v0.1.0" {
-			zip010 = buf.Bytes()
-		}
-		uploadFile(t, "local-go", mod+"/@v/"+ver+".zip", buf.Bytes(), "application/zip")
-		uploadFile(t, "local-go", mod+"/@v/"+ver+".mod", gomod, "text/plain")
-	}
-
-	resp, body := doRequest(t, http.MethodPut, api("/api/v2/remotes/local-go/files/"+mod+"/@v/v0.3.0.zip"), []byte("junk"), "application/zip")
-	if resp.StatusCode != http.StatusBadRequest {
-		t.Fatalf("invalid zip: status %d: %s", resp.StatusCode, body)
-	}
-
-	for path, want := range map[string]string{
-		"/@v/list":        "v0.1.0\nv0.2.0\n",
-		"/@latest":        `{"Version":"v0.2.0"}`,
-		"/@v/v0.1.0.info": `{"Version":"v0.1.0"}`,
-		"/@v/v0.1.0.mod":  string(gomod),
-		"/@v/v0.1.0.zip":  string(zip010),
-	} {
-		resp, body := doRequest(t, http.MethodGet, api("/api/v1/local/local-go/"+mod+path), nil, "")
-		if resp.StatusCode != http.StatusOK || string(body) != want {
-			t.Errorf("%s: status %d body %q", path, resp.StatusCode, body)
-		}
-	}
-}
@@ -0,0 +1,62 @@
+//go:build dockere2e
+
+package e2edocker
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestLocalNPMPublishInstall drives a stock npm client against a local npm
+// repo: publish unscoped and scoped packages, install and require() them in a
+// fresh project, publish a second version, and reject a republish.
+func TestLocalNPMPublishInstall(t *testing.T) {
+	network := os.Getenv("COMPOSE_NETWORK")
+	internal := os.Getenv("ARTIFACTAPI_INTERNAL")
+	if network == "" || internal == "" {
+		t.Skip("COMPOSE_NETWORK/ARTIFACTAPI_INTERNAL not set; run via scripts/docker-e2e.sh")
+	}
+	if _, err := exec.LookPath("docker"); err != nil {
+		t.Skip("docker not available on the test host")
+	}
+
+	name := fmt.Sprintf("e2e-npm-local-%d", time.Now().UnixNano())
+	createRepo(t, fmt.Sprintf(`{"name":%q,"package_type":"npm","repo_type":"local"}`, name))
+	defer deleteRepo(t, name)
+
+	reg := strings.TrimRight(internal, "/") + "/api/v1/local/" + name + "/"
+	script := `set -euo pipefail
+printf 'registry=%s\n%s:_authToken=unused\n' "$REG" "${REG#http:}" > ~/.npmrc
+mk() { d="/w/src/$1-$2"; mkdir -p "$d"; cd "$d"
+  printf '{"name":"%s","version":"%s","main":"index.js"}' "$1" "$2" > package.json
+  echo "module.exports = '$1@$2';" > index.js; }
+mk e2e-npm-plain 1.0.0 && npm publish
+mk @e2e/npm-scoped 1.0.0 && npm publish
+mk e2e-npm-plain 1.0.0
+if npm publish 2>/dev/null; then echo "republish accepted"; exit 1; fi
+mkdir -p /w/app && cd /w/app && npm init -y >/dev/null
+npm install --no-audit --cache /tmp/fresh-cache e2e-npm-plain @e2e/npm-scoped
+node -e "console.log('REQ', require('e2e-npm-plain'), require('@e2e/npm-scoped'))"
+mk e2e-npm-plain 1.1.0 && npm publish
+echo "VERSIONS $(npm view e2e-npm-plain versions --json | tr -d ' \n')"
+echo "LATEST $(npm view e2e-npm-plain dist-tags.latest)"`
+
+	out, err := exec.Command("docker", "run", "--rm", "--network", network,
+		"-e", "REG="+reg, "node:22", "bash", "-c", script).CombinedOutput()
+	if err != nil {
+		t.Fatalf("npm client run failed: %v\n%s", err, out)
+	}
+	for _, want := range []string{
+		"REQ e2e-npm-plain@1.0.0 @e2e/npm-scoped@1.0.0",
+		`VERSIONS ["1.0.0","1.1.0"]`,
+		"LATEST 1.1.0",
+	} {
+		if !strings.Contains(string(out), want) {
+			t.Fatalf("missing %q in npm output:\n%s", want, out)
+		}
+	}
+}
@@ -20,7 +20,6 @@ require (
 	github.com/testcontainers/testcontainers-go/modules/redis v0.42.0
 	github.com/ulikunitz/xz v0.5.16
 	golang.org/x/crypto v0.54.0
-	golang.org/x/mod v0.37.0
 	golang.org/x/sync v0.22.0
 	golang.org/x/time v0.15.0
 	gopkg.in/yaml.v3 v3.0.1
@@ -227,8 +227,6 @@ golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
 golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
-golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
-golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
 golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
 golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
 golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
@@ -249,8 +247,6 @@ golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
 golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
 golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
 golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
-golang.org/x/tools v0.47.0 h1:7Kn5x/d1svx/PzryTsqeoZN4TZwqeH5pGWjefhLi/1Q=
-golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
@@ -0,0 +1,286 @@
+package v1
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha1"
+	"crypto/sha512"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+
+	"git.unkin.net/unkin/artifactapi/internal/database"
+	"git.unkin.net/unkin/artifactapi/internal/storage"
+	"git.unkin.net/unkin/artifactapi/pkg/models"
+)
+
+// Local npm repos speak the npm registry publish/read protocol. Per package:
+//   <pkg>/-/<base>-<version>.tgz   tarball (immutable)
+//   <pkg>/-/<base>-<version>.json  version manifest (immutable)
+//   <pkg>/-/dist-tags/<tag>        version string (mutable)
+
+var (
+	npmNameRe = regexp.MustCompile(`^(@[a-z0-9][a-z0-9._~-]*/)?[a-z0-9][a-z0-9._~-]*$`)
+	npmRefRe  = regexp.MustCompile(`^[0-9A-Za-z][0-9A-Za-z.+_-]*$`)
+)
+
+func (h *ProxyHandler) localNPMRemote(r *http.Request, name string) (*models.Remote, bool) {
+	remote, err := h.db.GetRemote(r.Context(), name)
+	if err != nil {
+		return nil, false
+	}
+	return remote, remote.RepoType == models.RepoTypeLocal && remote.PackageType == models.PackageNPM
+}
+
+// npmPackageName returns the package a packument/publish path addresses, or ""
+// when the path is something else (e.g. a tarball under <pkg>/-/).
+func npmPackageName(raw string) string {
+	p, err := url.PathUnescape(raw)
+	if err != nil {
+		return ""
+	}
+	p = strings.TrimSuffix(p, "/")
+	if !npmNameRe.MatchString(p) {
+		return ""
+	}
+	return p
+}
+
+type npmRelease struct {
+	version  string
+	manifest []byte
+	tarball  []byte
+	tags     []string
+}
+
+func parseNPMPublish(body io.Reader, pkg string) (*npmRelease, error) {
+	var doc struct {
+		Name        string                     `json:"name"`
+		DistTags    map[string]string          `json:"dist-tags"`
+		Versions    map[string]json.RawMessage `json:"versions"`
+		Attachments map[string]struct {
+			Data string `json:"data"`
+		} `json:"_attachments"`
+	}
+	if err := json.NewDecoder(body).Decode(&doc); err != nil {
+		return nil, fmt.Errorf("invalid publish body: %w", err)
+	}
+	if doc.Name != pkg {
+		return nil, fmt.Errorf("body name %q does not match %q", doc.Name, pkg)
+	}
+	if len(doc.Versions) != 1 || len(doc.Attachments) != 1 {
+		return nil, errors.New("publish must carry exactly one version and one tarball")
+	}
+
+	rel := &npmRelease{}
+	for v, m := range doc.Versions {
+		rel.version, rel.manifest = v, m
+	}
+	if !npmRefRe.MatchString(rel.version) {
+		return nil, fmt.Errorf("invalid version %q", rel.version)
+	}
+	var meta struct {
+		Name    string `json:"name"`
+		Version string `json:"version"`
+		Dist    struct {
+			Integrity string `json:"integrity"`
+			Shasum    string `json:"shasum"`
+		} `json:"dist"`
+	}
+	if err := json.Unmarshal(rel.manifest, &meta); err != nil {
+		return nil, fmt.Errorf("invalid version manifest: %w", err)
+	}
+	if meta.Name != pkg || meta.Version != rel.version {
+		return nil, errors.New("version manifest name/version mismatch")
+	}
+
+	for _, a := range doc.Attachments {
+		tgz, err := base64.StdEncoding.DecodeString(a.Data)
+		if err != nil {
+			return nil, fmt.Errorf("invalid tarball encoding: %w", err)
+		}
+		rel.tarball = tgz
+	}
+	if err := verifyNPMDist(rel.tarball, meta.Dist.Integrity, meta.Dist.Shasum); err != nil {
+		return nil, err
+	}
+
+	for tag, v := range doc.DistTags {
+		if !npmRefRe.MatchString(tag) || v != rel.version {
+			return nil, fmt.Errorf("dist-tag %q must point at the published version", tag)
+		}
+		rel.tags = append(rel.tags, tag)
+	}
+	return rel, nil
+}
+
+func verifyNPMDist(tgz []byte, integrity, shasum string) error {
+	if b64, ok := strings.CutPrefix(integrity, "sha512-"); ok {
+		sum := sha512.Sum512(tgz)
+		if base64.StdEncoding.EncodeToString(sum[:]) != b64 {
+			return errors.New("tarball does not match dist.integrity")
+		}
+		return nil
+	}
+	if shasum != "" {
+		sum := sha1.Sum(tgz)
+		if hex.EncodeToString(sum[:]) != shasum {
+			return errors.New("tarball does not match dist.shasum")
+		}
+		return nil
+	}
+	return errors.New("version manifest carries no sha512 integrity or shasum")
+}
+
+func npmError(w http.ResponseWriter, status int, msg string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(map[string]string{"error": msg})
+}
+
+func (h *ProxyHandler) handleLocalPut(w http.ResponseWriter, r *http.Request) {
+	remote, ok := h.localNPMRemote(r, chi.URLParam(r, "localName"))
+	if !ok {
+		npmError(w, http.StatusMethodNotAllowed, "publish is only supported on local npm repositories")
+		return
+	}
+	pkg := npmPackageName(chi.URLParam(r, "*"))
+	if pkg == "" {
+		npmError(w, http.StatusBadRequest, "invalid package name")
+		return
+	}
+	rel, err := parseNPMPublish(r.Body, pkg)
+	if err != nil {
+		npmError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	base := pkg[strings.LastIndex(pkg, "/")+1:]
+	stem := pkg + "/-/" + base + "-" + rel.version
+	// The tarball's immutable row is the version's uniqueness gate.
+	if err := h.npmStore(r.Context(), remote.Name, stem+".tgz", rel.tarball, "application/octet-stream", false); err != nil {
+		if errors.Is(err, database.ErrAlreadyExists) {
+			npmError(w, http.StatusConflict, fmt.Sprintf("%s@%s already exists; overwrites are not allowed", pkg, rel.version))
+			return
+		}
+		npmError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if err := h.npmStore(r.Context(), remote.Name, stem+".json", rel.manifest, "application/json", false); err != nil {
+		npmError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	for _, tag := range rel.tags {
+		if err := h.npmStore(r.Context(), remote.Name, pkg+"/-/dist-tags/"+tag, []byte(rel.version), "text/plain", true); err != nil {
+			npmError(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+	}
+
+	slog.Info("local npm package published", "repo", remote.Name, "package", pkg, "version", rel.version)
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	json.NewEncoder(w).Encode(map[string]any{"ok": true, "id": pkg})
+}
+
+func (h *ProxyHandler) npmStore(ctx context.Context, repo, path string, data []byte, contentType string, mutable bool) error {
+	result, err := h.cas.Store(ctx, bytes.NewReader(data), contentType)
+	if err != nil {
+		return err
+	}
+	if err := h.db.UpsertBlob(ctx, result.ContentHash, result.S3Key, result.SizeBytes, contentType); err != nil {
+		return err
+	}
+	if mutable {
+		return h.db.UpsertLocalFile(ctx, repo, path, result.ContentHash)
+	}
+	return h.db.CreateLocalFile(ctx, repo, path, result.ContentHash)
+}
+
+func (h *ProxyHandler) readLocalBlob(ctx context.Context, contentHash string) ([]byte, error) {
+	reader, _, err := h.store.Download(ctx, storage.BlobKey(strings.TrimPrefix(contentHash, "sha256:")))
+	if err != nil {
+		return nil, err
+	}
+	defer reader.Close()
+	return io.ReadAll(reader)
+}
+
+func (h *ProxyHandler) serveNPMPackument(w http.ResponseWriter, r *http.Request, remote *models.Remote, pkg string) {
+	files, err := h.db.ListLocalFilesByPrefix(r.Context(), remote.Name, pkg+"/-/")
+	if err != nil {
+		npmError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	read := func(hash string) ([]byte, error) { return h.readLocalBlob(r.Context(), hash) }
+	tarballBase := fmt.Sprintf("%s://%s/api/v1/local/%s/", scheme(r), r.Host, remote.Name)
+	doc, err := buildNPMPackument(pkg, files, read, tarballBase)
+	if err != nil {
+		npmError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if doc == nil {
+		npmError(w, http.StatusNotFound, "not found")
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("X-Artifact-Source", "local")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(doc)
+}
+
+// buildNPMPackument returns nil when pkg has no published versions.
+func buildNPMPackument(pkg string, files []database.LocalFile, read func(hash string) ([]byte, error), tarballBase string) (map[string]any, error) {
+	prefix := pkg + "/-/"
+	versions := map[string]any{}
+	tags := map[string]string{}
+	for _, f := range files {
+		// LIKE treats '_' as a wildcard, so the prefix match can over-select.
+		rest, ok := strings.CutPrefix(f.FilePath, prefix)
+		if !ok {
+			continue
+		}
+		if tag, isTag := strings.CutPrefix(rest, "dist-tags/"); isTag {
+			v, err := read(f.ContentHash)
+			if err != nil {
+				return nil, err
+			}
+			tags[tag] = string(v)
+			continue
+		}
+		stem, isManifest := strings.CutSuffix(rest, ".json")
+		if !isManifest {
+			continue
+		}
+		raw, err := read(f.ContentHash)
+		if err != nil {
+			return nil, err
+		}
+		var m map[string]any
+		if err := json.Unmarshal(raw, &m); err != nil {
+			return nil, fmt.Errorf("manifest %s: %w", f.FilePath, err)
+		}
+		dist, _ := m["dist"].(map[string]any)
+		if dist == nil {
+			dist = map[string]any{}
+			m["dist"] = dist
+		}
+		dist["tarball"] = tarballBase + prefix + stem + ".tgz"
+		v, _ := m["version"].(string)
+		versions[v] = m
+	}
+	if len(versions) == 0 {
+		return nil, nil
+	}
+	return map[string]any{"_id": pkg, "name": pkg, "dist-tags": tags, "versions": versions}, nil
+}
@@ -0,0 +1,162 @@
+package v1
+
+import (
+	"crypto/sha1"
+	"crypto/sha512"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"git.unkin.net/unkin/artifactapi/internal/database"
+)
+
+func TestNPMPackageName(t *testing.T) {
+	tests := map[string]string{
+		"left-pad":                "left-pad",
+		"left-pad/":               "left-pad",
+		"@acme%2fwidget":          "@acme/widget",
+		"@acme%2Fwidget":          "@acme/widget",
+		"@acme/widget":            "@acme/widget",
+		"left-pad/-/left-pad.tgz": "",
+		"@acme/widget/-/w-1.tgz":  "",
+		"a/b":                     "",
+		"../etc":                  "",
+		"Upper":                   "",
+		"":                        "",
+	}
+	for in, want := range tests {
+		if got := npmPackageName(in); got != want {
+			t.Errorf("npmPackageName(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+type publishOpts struct {
+	bodyName, manifestName, version, integrity, shasum string
+	tags                                               map[string]string
+	extraVersion                                       bool
+}
+
+func publishBody(t *testing.T, pkg string, tgz []byte, o publishOpts) string {
+	t.Helper()
+	sha := sha512.Sum512(tgz)
+	sh1 := sha1.Sum(tgz)
+	if o.bodyName == "" {
+		o.bodyName = pkg
+	}
+	if o.manifestName == "" {
+		o.manifestName = pkg
+	}
+	if o.version == "" {
+		o.version = "1.0.0"
+	}
+	if o.integrity == "" {
+		o.integrity = "sha512-" + base64.StdEncoding.EncodeToString(sha[:])
+	}
+	if o.shasum == "" {
+		o.shasum = hex.EncodeToString(sh1[:])
+	}
+	if o.tags == nil {
+		o.tags = map[string]string{"latest": o.version}
+	}
+	versions := map[string]any{o.version: map[string]any{
+		"name": o.manifestName, "version": o.version, "main": "index.js",
+		"dist": map[string]any{"integrity": o.integrity, "shasum": o.shasum, "tarball": "http://elsewhere/x.tgz"},
+	}}
+	if o.extraVersion {
+		versions["2.0.0"] = map[string]any{"name": pkg, "version": "2.0.0"}
+	}
+	b, _ := json.Marshal(map[string]any{
+		"_id": pkg, "name": o.bodyName, "dist-tags": o.tags, "versions": versions,
+		"_attachments": map[string]any{pkg + "-" + o.version + ".tgz": map[string]any{
+			"content_type": "application/octet-stream", "data": base64.StdEncoding.EncodeToString(tgz), "length": len(tgz),
+		}},
+	})
+	return string(b)
+}
+
+func TestParseNPMPublish(t *testing.T) {
+	tgz := []byte("fake tarball bytes")
+
+	rel, err := parseNPMPublish(strings.NewReader(publishBody(t, "@acme/widget", tgz, publishOpts{tags: map[string]string{"latest": "1.0.0", "beta": "1.0.0"}})), "@acme/widget")
+	if err != nil {
+		t.Fatalf("valid scoped publish rejected: %v", err)
+	}
+	if rel.version != "1.0.0" || string(rel.tarball) != string(tgz) || len(rel.tags) != 2 {
+		t.Fatalf("unexpected release: %+v", rel)
+	}
+
+	if _, err := parseNPMPublish(strings.NewReader(publishBody(t, "left-pad", tgz, publishOpts{integrity: "none", shasum: hex.EncodeToString(make([]byte, 20))})), "left-pad"); err == nil {
+		t.Fatal("shasum fallback should reject a mismatched tarball")
+	}
+	if _, err := parseNPMPublish(strings.NewReader(publishBody(t, "left-pad", tgz, publishOpts{integrity: "none"})), "left-pad"); err != nil {
+		t.Fatalf("matching shasum fallback rejected: %v", err)
+	}
+
+	bad := map[string]publishOpts{
+		"body name mismatch":        {bodyName: "other"},
+		"manifest name mismatch":    {manifestName: "other"},
+		"integrity mismatch":        {integrity: "sha512-AAAA"},
+		"path-like version":         {version: "../1.0.0"},
+		"tag at another version":    {tags: map[string]string{"latest": "9.9.9"}},
+		"path-like tag":             {tags: map[string]string{"../x": "1.0.0"}},
+		"multiple versions at once": {extraVersion: true},
+	}
+	for name, o := range bad {
+		if _, err := parseNPMPublish(strings.NewReader(publishBody(t, "left-pad", tgz, o)), "left-pad"); err == nil {
+			t.Errorf("%s: expected rejection", name)
+		}
+	}
+	if _, err := parseNPMPublish(strings.NewReader(`{"name":"left-pad","versions":{}}`), "left-pad"); err == nil {
+		t.Error("deprecate-style body without attachments should be rejected")
+	}
+}
+
+func TestBuildNPMPackument(t *testing.T) {
+	blobs := map[string]string{
+		"h1": `{"name":"my_pkg","version":"1.0.0","dist":{"shasum":"aa","tarball":"http://elsewhere/x.tgz"}}`,
+		"h2": `{"name":"my_pkg","version":"1.1.0"}`,
+		"h3": "1.1.0",
+		"hx": `{"name":"myXpkg","version":"6.6.6"}`,
+	}
+	read := func(h string) ([]byte, error) {
+		b, ok := blobs[h]
+		if !ok {
+			return nil, errors.New("missing blob")
+		}
+		return []byte(b), nil
+	}
+	files := []database.LocalFile{
+		{FilePath: "my_pkg/-/dist-tags/latest", ContentHash: "h3"},
+		{FilePath: "my_pkg/-/my_pkg-1.0.0.json", ContentHash: "h1"},
+		{FilePath: "my_pkg/-/my_pkg-1.0.0.tgz", ContentHash: "nope"},
+		{FilePath: "my_pkg/-/my_pkg-1.1.0.json", ContentHash: "h2"},
+		{FilePath: "myXpkg/-/myXpkg-6.6.6.json", ContentHash: "hx"},
+	}
+
+	doc, err := buildNPMPackument("my_pkg", files, read, "http://reg/api/v1/local/npm/")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if tags := doc["dist-tags"].(map[string]string); tags["latest"] != "1.1.0" {
+		t.Errorf("dist-tags = %v", tags)
+	}
+	versions := doc["versions"].(map[string]any)
+	if len(versions) != 2 {
+		t.Fatalf("versions = %v (LIKE over-match must be dropped)", versions)
+	}
+	v1 := versions["1.0.0"].(map[string]any)["dist"].(map[string]any)
+	if v1["tarball"] != "http://reg/api/v1/local/npm/my_pkg/-/my_pkg-1.0.0.tgz" || v1["shasum"] != "aa" {
+		t.Errorf("1.0.0 dist = %v", v1)
+	}
+	if versions["1.1.0"].(map[string]any)["dist"].(map[string]any)["tarball"] != "http://reg/api/v1/local/npm/my_pkg/-/my_pkg-1.1.0.tgz" {
+		t.Error("1.1.0 missing rewritten tarball")
+	}
+
+	if doc, err := buildNPMPackument("absent", files, read, "x/"); err != nil || doc != nil {
+		t.Errorf("absent package: doc=%v err=%v", doc, err)
+	}
+}
@@ -15,6 +15,7 @@ import (
 	"git.unkin.net/unkin/artifactapi/internal/proxy"
 	"git.unkin.net/unkin/artifactapi/internal/storage"
 	"git.unkin.net/unkin/artifactapi/internal/virtual"
+	"git.unkin.net/unkin/artifactapi/pkg/models"
 )

 type ProxyHandler struct {
@@ -41,6 +42,7 @@ func (h *ProxyHandler) Routes() chi.Router {
 	r := chi.NewRouter()
 	r.Get("/remote/{remoteName}/*", h.handleProxy)
 	r.Get("/local/{localName}/*", h.handleLocal)
+	r.Put("/local/{localName}/*", h.handleLocalPut)
 	r.Get("/virtual/{virtualName}/*", h.handleVirtual)
 	return r
 }
@@ -199,6 +201,13 @@ func (h *ProxyHandler) handleLocal(w http.ResponseWriter, r *http.Request) {
 		return
 	}

+	if remote.PackageType == models.PackageNPM {
+		if pkg := npmPackageName(path); pkg != "" {
+			h.serveNPMPackument(w, r, remote, pkg)
+			return
+		}
+	}
+
 	prov, _ := provider.Get(remote.PackageType)
 	if indexer, ok := prov.(provider.LocalIndexer); ok {
 		if indexer.ServeLocalIndex(w, r, h.db, remote.Name, path) {
@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"os"

 	"github.com/go-chi/chi/v5"

@@ -84,22 +83,7 @@ func (h *LocalHandler) uploadValidated(w http.ResponseWriter, r *http.Request, r
 		return
 	}

-	var body io.Reader = r.Body
-	if cv, ok := prov.(provider.ContentValidator); ok {
-		f, err := spoolBody(r.Body)
-		if err != nil {
-			http.Error(w, fmt.Sprintf("read upload: %v", err), http.StatusInternalServerError)
-			return
-		}
-		defer discard(f)
-		if err := cv.ValidateContent(storagePath, f.Name()); err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		body = f
-	}
-
-	result, err := h.cas.Store(r.Context(), body, contentType)
+	result, err := h.cas.Store(r.Context(), r.Body, contentType)
 	if err != nil {
 		http.Error(w, fmt.Sprintf("store failed: %v", err), http.StatusInternalServerError)
 		return
@@ -126,27 +110,6 @@ func (h *LocalHandler) uploadValidated(w http.ResponseWriter, r *http.Request, r
 	writeJSON(w, http.StatusCreated, uploader.UploadResponse(storagePath, result.ContentHash, result.SizeBytes))
 }

-func spoolBody(r io.Reader) (*os.File, error) {
-	f, err := os.CreateTemp("", "artifactapi-upload-*")
-	if err != nil {
-		return nil, err
-	}
-	if _, err := io.Copy(f, r); err != nil {
-		discard(f)
-		return nil, err
-	}
-	if _, err := f.Seek(0, io.SeekStart); err != nil {
-		discard(f)
-		return nil, err
-	}
-	return f, nil
-}
-
-func discard(f *os.File) {
-	_ = f.Close()
-	_ = os.Remove(f.Name())
-}
-
 func (h *LocalHandler) uploadGeneric(w http.ResponseWriter, r *http.Request, remote *models.Remote, filePath string) {
 	existing, err := h.db.GetLocalFile(r.Context(), remote.Name, filePath)
 	if err != nil {
@@ -1,55 +0,0 @@
-package v2
-
-import (
-	"context"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/go-chi/chi/v5"
-
-	"git.unkin.net/unkin/artifactapi/internal/database"
-	_ "git.unkin.net/unkin/artifactapi/internal/provider/goproxy"
-	"git.unkin.net/unkin/artifactapi/pkg/models"
-)
-
-// TestLocalUploadContentRejected verifies a ContentValidator provider rejects
-// bad bytes with 400 before anything is stored.
-func TestLocalUploadContentRejected(t *testing.T) {
-	if testDSN == "" {
-		t.Skip("Docker unavailable")
-	}
-	ctx := context.Background()
-	db, err := database.New(testDSN)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	const repo = "go-local-validate"
-	if err := db.CreateRemote(ctx, &models.Remote{Name: repo, PackageType: models.PackageGoProxy, RepoType: models.RepoTypeLocal}); err != nil {
-		t.Fatal(err)
-	}
-
-	router := chi.NewRouter()
-	router.Route("/remotes/{name}/files", func(r chi.Router) {
-		r.Put("/*", NewLocalHandler(db, nil).Routes().ServeHTTP)
-	})
-
-	cases := map[string]string{
-		"example.unkin.net/hello/@v/v0.1.0.zip":  "not a zip",
-		"example.unkin.net/hello/@v/v0.1.0.mod":  "module example.unkin.net/other\n",
-		"example.unkin.net/hello/@v/v0.1.0.info": `{"Version":"v9.9.9"}`,
-		"example.unkin.net/Hello/@v/v0.1.0.mod":  "module example.unkin.net/Hello\n",
-	}
-	for path, body := range cases {
-		w := httptest.NewRecorder()
-		router.ServeHTTP(w, httptest.NewRequest("PUT", "/remotes/"+repo+"/files/"+path, strings.NewReader(body)))
-		if w.Code != 400 {
-			t.Errorf("%s: status %d, want 400 (%s)", path, w.Code, w.Body.String())
-		}
-		if f, _ := db.GetLocalFile(ctx, repo, path); f != nil {
-			t.Errorf("%s: rejected upload was recorded", path)
-		}
-	}
-}
@@ -1,222 +0,0 @@
-package goproxy
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"os"
-	"slices"
-	"strings"
-
-	"golang.org/x/mod/modfile"
-	"golang.org/x/mod/module"
-	"golang.org/x/mod/semver"
-	modzip "golang.org/x/mod/zip"
-
-	"git.unkin.net/unkin/artifactapi/internal/provider"
-)
-
-type versionFile struct {
-	module  string
-	version string
-	ext     string
-}
-
-// parseVersionFile splits "<escaped module>/@v/<version>.<ext>" into its parts.
-func parseVersionFile(path string) (versionFile, error) {
-	escMod, file, ok := strings.Cut(strings.TrimPrefix(path, "/"), "/@v/")
-	if !ok || escMod == "" || strings.Contains(file, "/") {
-		return versionFile{}, fmt.Errorf("path %q must be <module>/@v/<version>.{zip,mod,info}", path)
-	}
-	dot := strings.LastIndex(file, ".")
-	if dot <= 0 {
-		return versionFile{}, fmt.Errorf("path %q must end in .zip, .mod or .info", path)
-	}
-	ext := file[dot+1:]
-	if ext != "zip" && ext != "mod" && ext != "info" {
-		return versionFile{}, fmt.Errorf("path %q must end in .zip, .mod or .info", path)
-	}
-	mod, err := module.UnescapePath(escMod)
-	if err != nil {
-		return versionFile{}, fmt.Errorf("module path must be case-encoded (uppercase as !lower): %w", err)
-	}
-	ver, err := module.UnescapeVersion(file[:dot])
-	if err != nil {
-		return versionFile{}, err
-	}
-	if err := module.Check(mod, ver); err != nil {
-		return versionFile{}, err
-	}
-	if semver.Canonical(ver) != ver {
-		return versionFile{}, fmt.Errorf("version %q is not canonical semver", ver)
-	}
-	return versionFile{module: mod, version: ver, ext: ext}, nil
-}
-
-func (v versionFile) storagePath() string {
-	escMod, _ := module.EscapePath(v.module)
-	escVer, _ := module.EscapeVersion(v.version)
-	return escMod + "/@v/" + escVer + "." + v.ext
-}
-
-func (p *Provider) ValidateUpload(filePath string) (storagePath, contentType string, err error) {
-	vf, err := parseVersionFile(filePath)
-	if err != nil {
-		return "", "", err
-	}
-	sp := vf.storagePath()
-	return sp, p.ContentType(sp), nil
-}
-
-func (p *Provider) ValidateContent(storagePath, localFile string) error {
-	vf, err := parseVersionFile(storagePath)
-	if err != nil {
-		return err
-	}
-	switch vf.ext {
-	case "zip":
-		if _, err := modzip.CheckZip(module.Version{Path: vf.module, Version: vf.version}, localFile); err != nil {
-			return fmt.Errorf("invalid module zip (files must sit under %s@%s/): %w", vf.module, vf.version, err)
-		}
-	case "mod":
-		data, err := os.ReadFile(localFile)
-		if err != nil {
-			return err
-		}
-		mf, err := modfile.ParseLax("go.mod", data, nil)
-		if err != nil {
-			return fmt.Errorf("invalid go.mod: %w", err)
-		}
-		if mf.Module == nil || mf.Module.Mod.Path != vf.module {
-			return fmt.Errorf("go.mod must declare module %s", vf.module)
-		}
-	case "info":
-		data, err := os.ReadFile(localFile)
-		if err != nil {
-			return err
-		}
-		var info struct{ Version string }
-		if err := json.Unmarshal(data, &info); err != nil {
-			return fmt.Errorf("invalid .info JSON: %w", err)
-		}
-		if info.Version != vf.version {
-			return fmt.Errorf(".info Version %q does not match %s", info.Version, vf.version)
-		}
-	}
-	return nil
-}
-
-func (p *Provider) UploadResponse(storagePath, contentHash string, sizeBytes int64) map[string]any {
-	vf, _ := parseVersionFile(storagePath)
-	return map[string]any{
-		"module":       vf.module,
-		"version":      vf.version,
-		"path":         storagePath,
-		"content_hash": contentHash,
-		"size_bytes":   sizeBytes,
-	}
-}
-
-// versions returns the canonical versions of escMod that have a .mod uploaded, sorted ascending.
-func versions(ctx context.Context, files provider.FileStore, repoName, escMod string) (versions []string, infos map[string]bool, err error) {
-	entries, err := files.ListFilesByPrefix(ctx, repoName, escMod+"/@v/")
-	if err != nil {
-		return nil, nil, err
-	}
-	infos = map[string]bool{}
-	for _, e := range entries {
-		vf, err := parseVersionFile(e.FilePath)
-		if err != nil || vf.storagePath() != e.FilePath {
-			continue
-		}
-		switch vf.ext {
-		case "mod":
-			versions = append(versions, vf.version)
-		case "info":
-			infos[vf.version] = true
-		}
-	}
-	semver.Sort(versions)
-	return versions, infos, nil
-}
-
-func latest(vs []string) string {
-	for i := len(vs) - 1; i >= 0; i-- {
-		if semver.Prerelease(vs[i]) == "" {
-			return vs[i]
-		}
-	}
-	if len(vs) == 0 {
-		return ""
-	}
-	return vs[len(vs)-1]
-}
-
-func infoJSON(version string) []byte {
-	b, _ := json.Marshal(map[string]string{"Version": version})
-	return b
-}
-
-func (p *Provider) ServeLocalIndex(w http.ResponseWriter, r *http.Request, files provider.FileStore, repoName, path string) bool {
-	path = strings.TrimPrefix(path, "/")
-	switch {
-	case strings.HasSuffix(path, "/@v/list"), strings.HasSuffix(path, "/@latest"):
-	case strings.HasSuffix(path, ".info"):
-		vf, err := parseVersionFile(path)
-		if err != nil {
-			return false
-		}
-		escMod, _ := module.EscapePath(vf.module)
-		vs, infos, err := versions(r.Context(), files, repoName, escMod)
-		if err != nil || infos[vf.version] || !slices.Contains(vs, vf.version) {
-			return false
-		}
-	default:
-		return false
-	}
-
-	body, err := p.GenerateLocalIndex(r.Context(), files, repoName, path)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusNotFound)
-		return true
-	}
-	w.Header().Set("Content-Type", p.ContentType(path))
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write(body)
-	return true
-}
-
-func (p *Provider) GenerateLocalIndex(ctx context.Context, files provider.FileStore, repoName, path string) ([]byte, error) {
-	path = strings.TrimPrefix(path, "/")
-	if escMod, ok := strings.CutSuffix(path, "/@v/list"); ok {
-		vs, _, err := versions(ctx, files, repoName, escMod)
-		if err != nil {
-			return nil, err
-		}
-		var b strings.Builder
-		for _, v := range vs {
-			b.WriteString(v + "\n")
-		}
-		return []byte(b.String()), nil
-	}
-	if escMod, ok := strings.CutSuffix(path, "/@latest"); ok {
-		vs, _, err := versions(ctx, files, repoName, escMod)
-		if err != nil {
-			return nil, err
-		}
-		v := latest(vs)
-		if v == "" {
-			return nil, fmt.Errorf("no versions of %s", escMod)
-		}
-		return infoJSON(v), nil
-	}
-	if strings.HasSuffix(path, ".info") {
-		vf, err := parseVersionFile(path)
-		if err != nil {
-			return nil, err
-		}
-		return infoJSON(vf.version), nil
-	}
-	return nil, fmt.Errorf("unsupported index path: %q", path)
-}
@@ -1,198 +0,0 @@
-package goproxy
-
-import (
-	"archive/zip"
-	"context"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"golang.org/x/mod/module"
-	modzip "golang.org/x/mod/zip"
-
-	"git.unkin.net/unkin/artifactapi/internal/provider"
-)
-
-type fakeFileStore struct{ paths []string }
-
-func (f *fakeFileStore) ListPackages(context.Context, string) ([]string, error) { return nil, nil }
-
-func (f *fakeFileStore) ListFilesByPrefix(_ context.Context, _, prefix string) ([]provider.FileEntry, error) {
-	var out []provider.FileEntry
-	for _, p := range f.paths {
-		if strings.HasPrefix(p, prefix) {
-			out = append(out, provider.FileEntry{FilePath: p, ContentHash: "sha256:x"})
-		}
-	}
-	return out, nil
-}
-
-func TestValidateUpload(t *testing.T) {
-	p := &Provider{}
-	cases := []struct {
-		in, want string
-		ok       bool
-	}{
-		{"example.unkin.net/hello/@v/v0.1.0.zip", "example.unkin.net/hello/@v/v0.1.0.zip", true},
-		{"/example.unkin.net/hello/@v/v0.1.0.mod", "example.unkin.net/hello/@v/v0.1.0.mod", true},
-		{"github.com/!burnt!sushi/toml/@v/v1.2.0.info", "github.com/!burnt!sushi/toml/@v/v1.2.0.info", true},
-		{"example.unkin.net/hello/v2/@v/v2.0.0-rc.1.zip", "example.unkin.net/hello/v2/@v/v2.0.0-rc.1.zip", true},
-		{"github.com/BurntSushi/toml/@v/v1.2.0.zip", "", false},
-		{"example.unkin.net/hello/@v/v0.1.zip", "", false},
-		{"example.unkin.net/hello/@v/v2.0.0.zip", "", false},
-		{"example.unkin.net/hello/@v/v0.1.0.tar.gz", "", false},
-		{"example.unkin.net/hello/v0.1.0.zip", "", false},
-		{"example.unkin.net/hello/@v/list", "", false},
-	}
-	for _, c := range cases {
-		got, ct, err := p.ValidateUpload(c.in)
-		if (err == nil) != c.ok {
-			t.Errorf("%s: err=%v, want ok=%v", c.in, err, c.ok)
-			continue
-		}
-		if c.ok && (got != c.want || ct == "") {
-			t.Errorf("%s: got %q %q, want %q", c.in, got, ct, c.want)
-		}
-	}
-}
-
-func writeZip(t *testing.T, files map[string]string) string {
-	t.Helper()
-	path := filepath.Join(t.TempDir(), "m.zip")
-	f, err := os.Create(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	zw := zip.NewWriter(f)
-	for name, body := range files {
-		w, err := zw.Create(name)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := w.Write([]byte(body)); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := zw.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if err := f.Close(); err != nil {
-		t.Fatal(err)
-	}
-	return path
-}
-
-func writeFile(t *testing.T, body string) string {
-	t.Helper()
-	path := filepath.Join(t.TempDir(), "f")
-	if err := os.WriteFile(path, []byte(body), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	return path
-}
-
-func TestValidateContentZip(t *testing.T) {
-	p := &Provider{}
-	sp := "example.unkin.net/hello/@v/v0.1.0.zip"
-
-	dir := t.TempDir()
-	os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module example.unkin.net/hello\n"), 0o600)
-	os.WriteFile(filepath.Join(dir, "main.go"), []byte("package main\n"), 0o600)
-	good := filepath.Join(t.TempDir(), "good.zip")
-	f, _ := os.Create(good)
-	if err := modzip.CreateFromDir(f, module.Version{Path: "example.unkin.net/hello", Version: "v0.1.0"}, dir); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	if err := p.ValidateContent(sp, good); err != nil {
-		t.Errorf("valid zip rejected: %v", err)
-	}
-
-	bad := map[string]map[string]string{
-		"no prefix":     {"go.mod": "module example.unkin.net/hello\n"},
-		"wrong version": {"example.unkin.net/hello@v0.2.0/go.mod": "module example.unkin.net/hello\n"},
-		"wrong module":  {"example.unkin.net/other@v0.1.0/go.mod": "module example.unkin.net/other\n"},
-	}
-	for name, files := range bad {
-		if err := p.ValidateContent(sp, writeZip(t, files)); err == nil {
-			t.Errorf("%s: expected rejection", name)
-		}
-	}
-	if err := p.ValidateContent(sp, writeFile(t, "not a zip")); err == nil {
-		t.Error("non-zip accepted")
-	}
-}
-
-func TestValidateContentModInfo(t *testing.T) {
-	p := &Provider{}
-	mod := "example.unkin.net/hello/@v/v0.1.0.mod"
-	info := "example.unkin.net/hello/@v/v0.1.0.info"
-	cases := []struct {
-		path, body string
-		ok         bool
-	}{
-		{mod, "module example.unkin.net/hello\n\ngo 1.25\n", true},
-		{mod, "module example.unkin.net/other\n", false},
-		{mod, "go 1.25\n", false},
-		{mod, "module (\n", false},
-		{info, `{"Version":"v0.1.0","Time":"2026-01-01T00:00:00Z"}`, true},
-		{info, `{"Version":"v0.2.0"}`, false},
-		{info, `nope`, false},
-	}
-	for _, c := range cases {
-		if err := p.ValidateContent(c.path, writeFile(t, c.body)); (err == nil) != c.ok {
-			t.Errorf("%s %q: err=%v, want ok=%v", c.path, c.body, err, c.ok)
-		}
-	}
-}
-
-func serve(t *testing.T, fs provider.FileStore, path string) (bool, int, string) {
-	t.Helper()
-	rec := httptest.NewRecorder()
-	handled := (&Provider{}).ServeLocalIndex(rec, httptest.NewRequest("GET", "/"+path, nil), fs, "go-local", path)
-	return handled, rec.Code, rec.Body.String()
-}
-
-func TestServeLocalIndex(t *testing.T) {
-	fs := &fakeFileStore{paths: []string{
-		"example.unkin.net/hello/@v/v0.10.0.mod",
-		"example.unkin.net/hello/@v/v0.10.0.zip",
-		"example.unkin.net/hello/@v/v0.2.0.mod",
-		"example.unkin.net/hello/@v/v0.2.0.zip",
-		"example.unkin.net/hello/@v/v0.2.0.info",
-		"example.unkin.net/hello/@v/v0.11.0-rc.1.mod",
-		"example.unkin.net/hello/@v/v0.3.0.zip",
-		"example.unkin.net/hello/v2/@v/v2.0.0.mod",
-		"example.unkin.net/!pre/@v/v1.0.0-beta.mod",
-	}}
-
-	if h, code, body := serve(t, fs, "example.unkin.net/hello/@v/list"); !h || code != 200 || body != "v0.2.0\nv0.10.0\nv0.11.0-rc.1\n" {
-		t.Errorf("list: %v %d %q", h, code, body)
-	}
-	if h, code, body := serve(t, fs, "example.unkin.net/hello/@latest"); !h || code != 200 || body != `{"Version":"v0.10.0"}` {
-		t.Errorf("latest: %v %d %q", h, code, body)
-	}
-	if h, _, body := serve(t, fs, "example.unkin.net/!pre/@latest"); !h || body != `{"Version":"v1.0.0-beta"}` {
-		t.Errorf("prerelease-only latest: %q", body)
-	}
-	if h, code, _ := serve(t, fs, "example.unkin.net/missing/@latest"); !h || code != 404 {
-		t.Errorf("missing latest: %v %d", h, code)
-	}
-	if h, code, body := serve(t, fs, "example.unkin.net/missing/@v/list"); !h || code != 200 || body != "" {
-		t.Errorf("missing list: %v %d %q", h, code, body)
-	}
-	if h, _, body := serve(t, fs, "example.unkin.net/hello/@v/v0.10.0.info"); !h || body != `{"Version":"v0.10.0"}` {
-		t.Errorf("synthesized info: %v %q", h, body)
-	}
-	if h, _, _ := serve(t, fs, "example.unkin.net/hello/@v/v0.2.0.info"); h {
-		t.Error("uploaded .info must be served from storage")
-	}
-	if h, _, _ := serve(t, fs, "example.unkin.net/hello/@v/v0.3.0.info"); h {
-		t.Error(".info without a .mod must not be synthesized")
-	}
-	if h, _, _ := serve(t, fs, "example.unkin.net/hello/@v/v0.10.0.zip"); h {
-		t.Error(".zip must be served from storage")
-	}
-}
@@ -41,11 +41,6 @@ type LocalUploader interface {
 	UploadResponse(storagePath, contentHash string, sizeBytes int64) map[string]any
 }

-// ContentValidator checks an upload's bytes (spooled to localFile) before it is stored.
-type ContentValidator interface {
-	ValidateContent(storagePath, localFile string) error
-}
-
 type LocalIndexer interface {
 	ServeLocalIndex(w http.ResponseWriter, r *http.Request, files FileStore, repoName, path string) bool
 	GenerateLocalIndex(ctx context.Context, files FileStore, repoName, path string) ([]byte, error)
@@ -101,6 +101,27 @@ pip install <package>`,
      ];

    case 'npm':
+      if (isLocal) {
+        const reg = `${url}/api/v1/local/${name}/`;
+        return [
+          {
+            title: 'Configure .npmrc (registry + publish token)',
+            language: 'bash',
+            code: `cat >> .npmrc <<'EOF'
+registry=${reg}
+//${host}/api/v1/local/${name}/:_authToken=unused
+EOF`,
+            note: 'npm refuses to publish without an _authToken for the registry; any value works. For a scope only, use @<scope>:registry=… instead of registry=.',
+          },
+          {
+            title: 'Publish and install',
+            language: 'bash',
+            code: `npm publish
+npm install <package>`,
+            note: 'Versions are immutable: republishing an existing version is rejected. The dist-tags sent with the publish (latest, or --tag) move to the new version.',
+          },
+        ];
+      }
      return [
        {
          title: 'Point npm at this registry',
@@ -218,38 +239,15 @@ sudo apk add --allow-untrusted <package>`,
      ];

    case 'goproxy':
-      return isLocal
-        ? [
-            {
-              title: 'Fetch private modules from this proxy',
-              language: 'bash',
-              code: `export GOPROXY=${url}/api/v1/local/${name},https://proxy.golang.org,direct
-export GONOSUMDB=example.unkin.net
-go get example.unkin.net/hello@latest`,
-              note: 'Set GONOSUMDB (or GOPRIVATE) to your module prefix: private modules are not in sum.golang.org.',
-            },
-            {
-              title: 'Publish a module version',
-              language: 'bash',
-              code: `# build the zip with golang.org/x/mod/zip (CreateFromDir), or reuse
-# the .zip/.mod/.info from $(go env GOMODCACHE)/cache/download after go mod download
-MOD=example.unkin.net/hello VER=v0.1.0
-for ext in zip mod info; do
-  curl -fsSL --upload-file $VER.$ext \\
-    ${url}/api/v2/remotes/${name}/files/$MOD/@v/$VER.$ext
-done`,
-              note: 'Paths use the case-encoded module path (uppercase as !lower). Zips must hold every file under module@version/ and are rejected otherwise; .info is optional.',
-            },
-          ]
-        : [
-            {
-              title: 'Point the Go module proxy here',
-              language: 'bash',
-              code: `export GOPROXY=${proxy}
+      return [
+        {
+          title: 'Point the Go module proxy here',
+          language: 'bash',
+          code: `export GOPROXY=${proxy}
 go mod download`,
-              note: 'Append ,direct to fall back to VCS for modules this proxy does not cover.',
-            },
-          ];
+          note: 'Append ,direct to fall back to VCS for modules this proxy does not cover.',
+        },
+      ];

    case 'cargo':
      return [