-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT

-- | Native npm inventory reads retain compact witnesses for the shared release decoder.
module Ecluse.Core.Registry.Npm.VersionListReader (npmVersionListWalk) where

import Data.Aeson (Value (Null, Number, Object, String))
import Data.Aeson.Key qualified as Key
import Data.Aeson.KeyMap qualified as KeyMap
import Data.JsonStream.Lexer (Cursor, Element (..))

import Ecluse.Core.Registry.Json.Intern (SipKey (SipKey), nameBytes, nameText, newInternTable)
import Ecluse.Core.Registry.Json.Shape (Mode (Keep), Shape (..), Trees (Trees), namedMembers, readShape)
import Ecluse.Core.Registry.Json.Walk (Step, Walk (finish), eachMember, emit, isString, pureStep, readString, skipFrom, tooDeep, withElement)
import Ecluse.Core.Registry.Npm.Project (projectVersionListEntry)
import Ecluse.Core.Registry.VersionList (VersionListItem (..))
import Ecluse.Core.Security (LimitError, Limits, maxNestingDepth)

-- | Count every source entry, including unusable releases, without retaining its installation metadata.
npmVersionListWalk :: Limits -> (s -> VersionListItem -> Either LimitError s) -> s -> Cursor -> Step s
npmVersionListWalk :: forall s.
Limits
-> (s -> VersionListItem -> Either LimitError s)
-> s
-> Cursor
-> Step s
npmVersionListWalk Limits
limits s -> VersionListItem -> Either LimitError s
step s
initial Cursor
tokens = Cursor -> (Element -> Cursor -> Step s) -> Step s
forall r. Walk r => Cursor -> (Element -> Cursor -> r) -> r
withElement Cursor
tokens ((Element -> Cursor -> Step s) -> Step s)
-> (Element -> Cursor -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \Element
element Cursor
rest -> case Element
element of
    Element
ObjectBegin -> s -> VersionListItem -> (s -> Step s) -> Step s
send s
initial VersionListItem
VersionListObject ((s -> Step s) -> Step s) -> (s -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \s
begun ->
        if Int
depth Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0
            then Element -> Cursor -> Step s
forall r. Walk r => Element -> Cursor -> r
tooDeep Element
element Cursor
rest
            else (s -> Name -> Cursor -> (s -> Cursor -> Step s) -> Step s)
-> (s -> Cursor -> Step s) -> s -> Cursor -> Step s
forall r st.
Walk r =>
(st -> Name -> Cursor -> (st -> Cursor -> r) -> r)
-> (st -> Cursor -> r) -> st -> Cursor -> r
eachMember s -> Name -> Cursor -> (s -> Cursor -> Step s) -> Step s
topField (\s
acc Cursor
_ -> s -> VersionListItem -> (s -> Step s) -> Step s
send s
acc VersionListItem
VersionListObject s -> Step s
Result (Step s) -> Step s
forall r. Walk r => Result r -> r
finish) s
begun Cursor
rest
    Element
_ -> Element -> Cursor -> (Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
element Cursor
rest (Step s -> Cursor -> Step s
forall a b. a -> b -> a
const (Result (Step s) -> Step s
forall r. Walk r => Result r -> r
finish s
Result (Step s)
initial))
  where
    depth :: Int
depth = Limits -> Int
maxNestingDepth Limits
limits
    send :: s -> VersionListItem -> (s -> Step s) -> Step s
send = FieldStep s VersionListItem (Step s)
-> s -> VersionListItem -> (s -> Step s) -> Step s
forall r s field.
Walk r =>
FieldStep s field r -> s -> field -> (s -> r) -> r
emit ((s -> VersionListItem -> Either LimitError s)
-> FieldStep s VersionListItem (Step s)
forall s field r.
(s -> field -> Either LimitError s) -> FieldStep s field r
pureStep s -> VersionListItem -> Either LimitError s
step)
    topField :: s -> Name -> Cursor -> (s -> Cursor -> Step s) -> Step s
topField s
acc Name
key Cursor
after s -> Cursor -> Step s
continue
        | Name -> ByteString
nameBytes Name
key ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"versions" = Cursor -> (Element -> Cursor -> Step s) -> Step s
forall r. Walk r => Cursor -> (Element -> Cursor -> r) -> r
withElement Cursor
after ((Element -> Cursor -> Step s) -> Step s)
-> (Element -> Cursor -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \Element
element Cursor
rest ->
            if Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0
                then Element -> Cursor -> Step s
forall r. Walk r => Element -> Cursor -> r
tooDeep Element
element Cursor
rest
                else case Element
element of
                    Element
ObjectBegin -> s -> VersionListItem -> (s -> Step s) -> Step s
send s
acc VersionListItem
VersionListContainer ((s -> Step s) -> Step s) -> (s -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \s
begun -> (s -> Name -> Cursor -> (s -> Cursor -> Step s) -> Step s)
-> (s -> Cursor -> Step s) -> s -> Cursor -> Step s
forall r st.
Walk r =>
(st -> Name -> Cursor -> (st -> Cursor -> r) -> r)
-> (st -> Cursor -> r) -> st -> Cursor -> r
eachMember s -> Name -> Cursor -> (s -> Cursor -> Step s) -> Step s
release s -> Cursor -> Step s
continue s
begun Cursor
rest
                    JValue Value
Null -> s -> VersionListItem -> (s -> Step s) -> Step s
send s
acc VersionListItem
VersionListContainer (s -> Cursor -> Step s
`continue` Cursor
rest)
                    Element
_ -> Element -> Cursor -> (Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
element Cursor
rest (\Cursor
afterValue -> s -> VersionListItem -> (s -> Step s) -> Step s
send s
acc VersionListItem
VersionListInvalidContainer (s -> Cursor -> Step s
`continue` Cursor
afterValue))
        | Bool
otherwise = Cursor -> (Element -> Cursor -> Step s) -> Step s
forall r. Walk r => Cursor -> (Element -> Cursor -> r) -> r
withElement Cursor
after ((Element -> Cursor -> Step s) -> Step s)
-> (Element -> Cursor -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \Element
element Cursor
rest -> Element -> Cursor -> (Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
element Cursor
rest (s -> Cursor -> Step s
continue s
acc)
    release :: s -> Name -> Cursor -> (s -> Cursor -> Step s) -> Step s
release s
acc Name
key Cursor
after s -> Cursor -> Step s
continue = Cursor -> (Element -> Cursor -> Step s) -> Step s
forall r. Walk r => Cursor -> (Element -> Cursor -> r) -> r
withElement Cursor
after ((Element -> Cursor -> Step s) -> Step s)
-> (Element -> Cursor -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \Element
element Cursor
rest ->
        Int
-> (ByteString -> Maybe (Key, WitnessReader s)) -> WitnessReader s
forall s.
Int
-> (ByteString -> Maybe (Key, WitnessReader s)) -> WitnessReader s
readWitnessObject (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
2) (Int -> ByteString -> Maybe (Key, WitnessReader s)
forall s. Int -> ByteString -> Maybe (Key, WitnessReader s)
releaseField Int
depth) Element
element Cursor
rest ((Value -> Cursor -> Step s) -> Step s)
-> (Value -> Cursor -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \Value
raw Cursor
afterValue ->
            s -> VersionListItem -> (s -> Step s) -> Step s
send s
acc (Text -> Maybe Value -> VersionListItem
projectVersionListEntry (Name -> Text
nameText Name
key) (Value -> Maybe Value
forall a. a -> Maybe a
Just Value
raw)) (s -> Cursor -> Step s
`continue` Cursor
afterValue)

type WitnessReader s = Element -> Cursor -> (Value -> Cursor -> Step s) -> Step s

releaseField :: Int -> ByteString -> Maybe (Key.Key, WitnessReader s)
releaseField :: forall s. Int -> ByteString -> Maybe (Key, WitnessReader s)
releaseField Int
depth = \case
    ByteString
"name" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"name", Int -> WitnessReader s
forall s. Int -> WitnessReader s
stringWitness (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
3))
    ByteString
"version" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"version", Int -> WitnessReader s
forall s. Int -> WitnessReader s
stringWitness (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
3))
    ByteString
"dist" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"dist", Int
-> (ByteString -> Maybe (Key, WitnessReader s)) -> WitnessReader s
forall s.
Int
-> (ByteString -> Maybe (Key, WitnessReader s)) -> WitnessReader s
readWitnessObject (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
3) (Int -> ByteString -> Maybe (Key, WitnessReader s)
forall s. Int -> ByteString -> Maybe (Key, WitnessReader s)
distField (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
4)))
    ByteString
"scripts" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"scripts", Int -> WitnessReader s
forall s. Int -> WitnessReader s
scriptsWitness (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
3))
    ByteString
"deprecated" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"deprecated", Int -> WitnessReader s
forall s. Int -> WitnessReader s
ignoredWitness (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
3))
    ByteString
"hasInstallScript" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"hasInstallScript", Shape -> WitnessReader s
forall s. Shape -> WitnessReader s
shapedWitness (Int -> Shape
Scalar (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
3)))
    ByteString
"license" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"license", Shape -> WitnessReader s
forall s. Shape -> WitnessReader s
shapedWitness ([Text] -> Int -> Shape
personShape [Text
"type", Text
"url"] (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
3)))
    ByteString
"_npmUser" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"_npmUser", Shape -> WitnessReader s
forall s. Shape -> WitnessReader s
shapedWitness ([Text] -> Int -> Shape
personShape [Text
"name", Text
"email", Text
"url"] (Int
depth Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
3)))
    ByteString
_ -> Maybe (Key, WitnessReader s)
forall a. Maybe a
Nothing

distField :: Int -> ByteString -> Maybe (Key.Key, WitnessReader s)
distField :: forall s. Int -> ByteString -> Maybe (Key, WitnessReader s)
distField Int
budget = \case
    ByteString
"tarball" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"tarball", Int -> WitnessReader s
forall s. Int -> WitnessReader s
stringWitness Int
budget)
    ByteString
"shasum" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"shasum", Int -> WitnessReader s
forall s. Int -> WitnessReader s
stringWitness Int
budget)
    ByteString
"integrity" -> (Key, WitnessReader s) -> Maybe (Key, WitnessReader s)
forall a. a -> Maybe a
Just (Key
"integrity", Int -> WitnessReader s
forall s. Int -> WitnessReader s
stringWitness Int
budget)
    ByteString
_ -> Maybe (Key, WitnessReader s)
forall a. Maybe a
Nothing

readWitnessObject :: Int -> (ByteString -> Maybe (Key.Key, WitnessReader s)) -> WitnessReader s
readWitnessObject :: forall s.
Int
-> (ByteString -> Maybe (Key, WitnessReader s)) -> WitnessReader s
readWitnessObject Int
budget ByteString -> Maybe (Key, WitnessReader s)
field Element
element Cursor
rest Value -> Cursor -> Step s
next
    | Int
budget Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = Element -> Cursor -> Step s
forall r. Walk r => Element -> Cursor -> r
tooDeep Element
element Cursor
rest
    | Element
ObjectBegin <- Element
element = (KeyMap Value
 -> Name -> Cursor -> (KeyMap Value -> Cursor -> Step s) -> Step s)
-> (KeyMap Value -> Cursor -> Step s)
-> KeyMap Value
-> Cursor
-> Step s
forall r st.
Walk r =>
(st -> Name -> Cursor -> (st -> Cursor -> r) -> r)
-> (st -> Cursor -> r) -> st -> Cursor -> r
eachMember KeyMap Value
-> Name -> Cursor -> (KeyMap Value -> Cursor -> Step s) -> Step s
member (Value -> Cursor -> Step s
next (Value -> Cursor -> Step s)
-> (KeyMap Value -> Value) -> KeyMap Value -> Cursor -> Step s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap Value -> Value
Object) KeyMap Value
forall a. Monoid a => a
mempty Cursor
rest
    | Bool
otherwise = Element -> Cursor -> (Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
element Cursor
rest (Value -> Cursor -> Step s
next Value
Null)
  where
    member :: KeyMap Value
-> Name -> Cursor -> (KeyMap Value -> Cursor -> Step s) -> Step s
member KeyMap Value
fields Name
name Cursor
after KeyMap Value -> Cursor -> Step s
continue = Cursor -> (Element -> Cursor -> Step s) -> Step s
forall r. Walk r => Cursor -> (Element -> Cursor -> r) -> r
withElement Cursor
after ((Element -> Cursor -> Step s) -> Step s)
-> (Element -> Cursor -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \Element
value Cursor
afterKey -> case ByteString -> Maybe (Key, WitnessReader s)
field (Name -> ByteString
nameBytes Name
name) of
        Maybe (Key, WitnessReader s)
Nothing -> Element -> Cursor -> (Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
value Cursor
afterKey (KeyMap Value -> Cursor -> Step s
continue KeyMap Value
fields)
        Just (Key
key, WitnessReader s
readValue) -> WitnessReader s
readValue Element
value Cursor
afterKey ((Value -> Cursor -> Step s) -> Step s)
-> (Value -> Cursor -> Step s) -> Step s
forall a b. (a -> b) -> a -> b
$ \Value
witness Cursor
afterValue ->
            KeyMap Value -> Cursor -> Step s
continue (if Key -> KeyMap Value -> Bool
forall a. Key -> KeyMap a -> Bool
KeyMap.member Key
key KeyMap Value
fields then KeyMap Value
fields else Key -> Value -> KeyMap Value -> KeyMap Value
forall v. Key -> v -> KeyMap v -> KeyMap v
KeyMap.insert Key
key Value
witness KeyMap Value
fields) Cursor
afterValue

stringWitness :: Int -> WitnessReader s
stringWitness :: forall s. Int -> WitnessReader s
stringWitness Int
budget Element
element Cursor
rest Value -> Cursor -> Step s
next
    | Int
budget Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = Element -> Cursor -> Step s
forall r. Walk r => Element -> Cursor -> r
tooDeep Element
element Cursor
rest
    | Element -> Bool
isString Element
element = Element -> Cursor -> (Name -> Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Name -> Cursor -> r) -> r
readString Element
element Cursor
rest (\Name
_ -> Value -> Cursor -> Step s
next (Text -> Value
String Text
""))
    | JValue Value
Null <- Element
element = Value -> Cursor -> Step s
next Value
Null Cursor
rest
    | Bool
otherwise = Element -> Cursor -> (Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
element Cursor
rest (Value -> Cursor -> Step s
next (Scientific -> Value
Number Scientific
0))

ignoredWitness :: Int -> WitnessReader s
ignoredWitness :: forall s. Int -> WitnessReader s
ignoredWitness Int
budget Element
element Cursor
rest Value -> Cursor -> Step s
next
    | Int
budget Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = Element -> Cursor -> Step s
forall r. Walk r => Element -> Cursor -> r
tooDeep Element
element Cursor
rest
    | Bool
otherwise = Element -> Cursor -> (Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
element Cursor
rest (Value -> Cursor -> Step s
next Value
Null)

scriptsWitness :: Int -> WitnessReader s
scriptsWitness :: forall s. Int -> WitnessReader s
scriptsWitness Int
budget Element
element Cursor
rest Value -> Cursor -> Step s
next
    | Int
budget Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = Element -> Cursor -> Step s
forall r. Walk r => Element -> Cursor -> r
tooDeep Element
element Cursor
rest
    | Element
ObjectBegin <- Element
element = (Bool -> Name -> Cursor -> (Bool -> Cursor -> Step s) -> Step s)
-> (Bool -> Cursor -> Step s) -> Bool -> Cursor -> Step s
forall r st.
Walk r =>
(st -> Name -> Cursor -> (st -> Cursor -> r) -> r)
-> (st -> Cursor -> r) -> st -> Cursor -> r
eachMember Bool -> Name -> Cursor -> (Bool -> Cursor -> Step s) -> Step s
forall {r} {p}.
Walk r =>
Bool -> p -> Cursor -> (Bool -> Cursor -> r) -> r
member (\Bool
valid -> Value -> Cursor -> Step s
next (if Bool
valid then KeyMap Value -> Value
Object KeyMap Value
forall a. Monoid a => a
mempty else Scientific -> Value
Number Scientific
0)) Bool
True Cursor
rest
    | JValue Value
Null <- Element
element = Value -> Cursor -> Step s
next Value
Null Cursor
rest
    | Bool
otherwise = Element -> Cursor -> (Cursor -> Step s) -> Step s
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
element Cursor
rest (Value -> Cursor -> Step s
next (Scientific -> Value
Number Scientific
0))
  where
    -- Every duplicate value participates. A later valid value cannot repair an invalid one.
    member :: Bool -> p -> Cursor -> (Bool -> Cursor -> r) -> r
member Bool
valid p
_ Cursor
after Bool -> Cursor -> r
continue = Cursor -> (Element -> Cursor -> r) -> r
forall r. Walk r => Cursor -> (Element -> Cursor -> r) -> r
withElement Cursor
after ((Element -> Cursor -> r) -> r) -> (Element -> Cursor -> r) -> r
forall a b. (a -> b) -> a -> b
$ \Element
value Cursor
afterKey ->
        if Int
budget Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0
            then Element -> Cursor -> r
forall r. Walk r => Element -> Cursor -> r
tooDeep Element
value Cursor
afterKey
            else
                if Element -> Bool
isString Element
value
                    then Element -> Cursor -> (Name -> Cursor -> r) -> r
forall r. Walk r => Element -> Cursor -> (Name -> Cursor -> r) -> r
readString Element
value Cursor
afterKey (\Name
_ -> Bool -> Cursor -> r
continue Bool
valid)
                    else Element -> Cursor -> (Cursor -> r) -> r
forall r. Walk r => Element -> Cursor -> (Cursor -> r) -> r
skipFrom Element
value Cursor
afterKey (Bool -> Cursor -> r
continue Bool
False)

personShape :: [Text] -> Int -> Shape
personShape :: [Text] -> Int -> Shape
personShape [Text]
keys Int
budget = Int -> Shape -> Shape
StringOr Int
budget (Int -> Members -> Shape -> Shape
ObjectWith Int
budget ([(Text, Shape)] -> Members
namedMembers [(Text
key, Int -> Shape
Scalar (Int
budget Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)) | Text
key <- [Text]
keys]) (Int -> Shape
Scalar Int
budget))

-- Keep never inserts source keys or strings, so this empty table does not hash upstream data.
shapedWitness :: Shape -> WitnessReader s
shapedWitness :: forall s. Shape -> WitnessReader s
shapedWitness Shape
shape Element
element Cursor
rest Value -> Cursor -> Step s
next =
    Trees
-> Shape
-> Mode
-> InternTable
-> Element
-> Cursor
-> (Built Trees -> InternTable -> Cursor -> Step s)
-> Step s
forall b r.
Build b r =>
b
-> Shape
-> Mode
-> InternTable
-> Element
-> Cursor
-> (Built b -> InternTable -> Cursor -> r)
-> r
readShape Trees
Trees Shape
shape Mode
Keep (SipKey -> [Text] -> InternTable
newInternTable (Word64 -> Word64 -> SipKey
SipKey Word64
0 Word64
0) []) Element
element Cursor
rest (\Built Trees
value InternTable
_ -> Value -> Cursor -> Step s
next Value
Built Trees
value)