{
  "schema": 1,
  "sample": true,
  "packages": [
    {
      "name": "cinch-base",
      "version": "0.1.0",
      "versions": [
        "0.1.0"
      ],
      "category": "Core",
      "synopsis": "The core types, list operations, and abstractions used throughout Cinch programs.",
      "description": "The core types, list operations, and abstractions used throughout Cinch programs.",
      "license": "BSD-3-Clause",
      "maintainer": "Cinch contributors",
      "updated": "2026-10-28",
      "dependencies": [],
      "modules": [
        {
          "name": "Prelude",
          "description": "Primitive types and the common vocabulary shared by the standard libraries.",
          "declarations": [
            {
              "name": "Nat",
              "kind": "type",
              "signature": "data Nat",
              "description": "An unbounded natural number. Arithmetic on Nat does not overflow.",
              "constructors": [
                {
                  "name": "Zero",
                  "signature": "Zero :: Nat",
                  "description": "The natural number zero."
                },
                {
                  "name": "Succ",
                  "signature": "Succ :: Nat -> Nat",
                  "description": "The successor of a natural number."
                }
              ]
            },
            {
              "name": "Bool",
              "kind": "type",
              "signature": "data Bool",
              "description": "A truth value.",
              "constructors": [
                {
                  "name": "False",
                  "signature": "False :: Bool",
                  "description": "False."
                },
                {
                  "name": "True",
                  "signature": "True :: Bool",
                  "description": "True."
                }
              ]
            },
            {
              "name": "Int",
              "kind": "type",
              "signature": "opaque Int",
              "description": "An unbounded signed integer."
            },
            {
              "name": "String",
              "kind": "type",
              "signature": "opaque String",
              "description": "An immutable string of Unicode text."
            },
            {
              "name": "Ref",
              "kind": "type",
              "signature": "opaque Ref region a",
              "description": "A reference that borrows a value for the lifetime of region."
            },
            {
              "name": "Unit",
              "kind": "type",
              "signature": "data Unit",
              "description": "The type with a single value, ()."
            },
            {
              "name": "Bytes",
              "kind": "type",
              "signature": "opaque Bytes",
              "description": "An immutable sequence of bytes."
            },
            {
              "name": "Io",
              "kind": "type",
              "signature": "effect Io region",
              "description": "An effect for interaction with an external environment."
            },
            {
              "name": "Ord",
              "kind": "class",
              "signature": "signature Ord a",
              "description": "A total ordering on values of a type."
            },
            {
              "name": "id",
              "kind": "function",
              "signature": "id :: forall a. a -> a",
              "description": "Return the supplied value unchanged.",
              "example": "id 42\n-- 42"
            },
            {
              "name": "const",
              "kind": "function",
              "signature": "const :: forall a b. a -> b -> a",
              "description": "Return the first argument and ignore the second."
            }
          ],
          "imports": []
        },
        {
          "name": "Data.Option",
          "description": "Values that may be absent, without sentinel values or null.",
          "declarations": [
            {
              "name": "Option",
              "kind": "type",
              "signature": "data Option a",
              "description": "Either a present value or its absence.",
              "constructors": [
                {
                  "name": "None",
                  "signature": "None :: Option a",
                  "description": "No value is present."
                },
                {
                  "name": "Some",
                  "signature": "Some :: a -> Option a",
                  "description": "A present value."
                }
              ]
            },
            {
              "name": "map",
              "kind": "function",
              "signature": "map :: forall a b. (a -> b) -> Option a -> Option b",
              "description": "Apply a function to a present value. None remains None.",
              "example": "map (\\x -> x + 1) (Some 4)\n-- Some 5"
            },
            {
              "name": "with-default",
              "kind": "function",
              "signature": "with-default :: forall a. a -> Option a -> a",
              "description": "Extract a present value, or return the supplied default.",
              "example": "with-default 0 None\n-- 0"
            },
            {
              "name": "is-some",
              "kind": "function",
              "signature": "is-some :: forall a. Option a -> Bool",
              "description": "Report whether a value is present."
            }
          ],
          "imports": []
        },
        {
          "name": "Data.List",
          "description": "Finite, ordered collections with structural recursion and total projections.",
          "declarations": [
            {
              "name": "List",
              "kind": "type",
              "signature": "data List a",
              "description": "A finite sequence of values of the same type.",
              "constructors": [
                {
                  "name": "Nil",
                  "signature": "Nil :: List a",
                  "description": "An empty list."
                },
                {
                  "name": "Cons",
                  "signature": "Cons :: a -> List a -> List a",
                  "description": "A head element and the remaining list."
                }
              ]
            },
            {
              "name": "map",
              "kind": "function",
              "signature": "map :: forall a b. (a -> b) -> List a -> List b",
              "description": "Transform each element, retaining the order of the input.",
              "example": "map (\\x -> x * 2) [1, 2, 3]\n-- [2, 4, 6]"
            },
            {
              "name": "foldr",
              "kind": "function",
              "signature": "foldr :: forall a b. (a -> b -> b) -> b -> List a -> b",
              "description": "Fold a list from the right using a combining function and an initial value."
            },
            {
              "name": "length",
              "kind": "function",
              "signature": "length :: forall a. List a -> Nat",
              "description": "Count the elements in a finite list.",
              "example": "length [1, 2, 3]\n-- 3"
            },
            {
              "name": "head",
              "kind": "function",
              "signature": "head :: forall a. List a -> Option a",
              "description": "Return the first element when present. An empty list produces None.",
              "example": "head []\n-- None"
            },
            {
              "name": "filter",
              "kind": "function",
              "signature": "filter :: forall a. (a -> Bool) -> List a -> List a",
              "description": "Retain elements that satisfy the predicate, in their original order."
            }
          ],
          "imports": [
            "Prelude",
            "Data.Option"
          ]
        },
        {
          "name": "Data.Result",
          "description": "Recoverable errors carried in the result type.",
          "declarations": [
            {
              "name": "Result",
              "kind": "type",
              "signature": "data Result e a",
              "description": "A successful value or a recoverable error.",
              "constructors": [
                {
                  "name": "Err",
                  "signature": "Err :: e -> Result e a",
                  "description": "A recoverable failure."
                },
                {
                  "name": "Ok",
                  "signature": "Ok :: a -> Result e a",
                  "description": "A successful result."
                }
              ]
            },
            {
              "name": "map",
              "kind": "function",
              "signature": "map :: forall e a b. (a -> b) -> Result e a -> Result e b",
              "description": "Transform a successful result, preserving an error."
            },
            {
              "name": "map-error",
              "kind": "function",
              "signature": "map-error :: forall e f a. (e -> f) -> Result e a -> Result f a",
              "description": "Transform the error while leaving successful values alone."
            }
          ],
          "imports": []
        }
      ],
      "readme": [
        "The core types, list operations, and abstractions used throughout Cinch programs.",
        "Import a module explicitly to use its types and functions. The module reference lists declarations, examples, and links to related types.",
        "This package is part of the sample catalogue used to develop Cinch’s package documentation site."
      ]
    },
    {
      "name": "cinch-collections",
      "version": "0.2.1",
      "versions": [
        "0.2.1",
        "0.2.0"
      ],
      "category": "Data",
      "synopsis": "Persistent maps, sets, and nonempty collections.",
      "description": "Persistent maps, sets, and nonempty collections.",
      "license": "BSD-3-Clause",
      "maintainer": "Cinch contributors",
      "updated": "2026-10-28",
      "dependencies": [
        "cinch-base"
      ],
      "modules": [
        {
          "name": "Data.Map",
          "description": "Ordered, persistent key-value maps.",
          "declarations": [
            {
              "name": "Map",
              "kind": "type",
              "signature": "opaque Map k v",
              "description": "A persistent mapping from ordered keys to values."
            },
            {
              "name": "empty",
              "kind": "function",
              "signature": "empty :: forall k v. Map k v",
              "description": "Construct an empty map."
            },
            {
              "name": "insert",
              "kind": "function",
              "signature": "insert :: forall k v. using (ord :: Ord k) => k -> v -> Map k v -> Map k v",
              "description": "Insert a value. An existing value at the same key is replaced."
            },
            {
              "name": "lookup",
              "kind": "function",
              "signature": "lookup :: forall k v. using (ord :: Ord k) => k -> Map k v -> Option v",
              "description": "Find the value associated with a key.",
              "example": "lookup \"port\" (insert \"port\" 8080 empty)\n-- Some 8080"
            },
            {
              "name": "keys",
              "kind": "function",
              "signature": "keys :: forall k v. Map k v -> List k",
              "description": "Return keys in ascending order.",
              "since": "0.2.1"
            }
          ],
          "imports": [
            "Prelude",
            "Data.Option",
            "Data.List"
          ]
        },
        {
          "name": "Data.Set",
          "description": "Persistent collections of distinct values.",
          "declarations": [
            {
              "name": "Set",
              "kind": "type",
              "signature": "opaque Set a",
              "description": "A collection containing each value at most once."
            },
            {
              "name": "empty",
              "kind": "function",
              "signature": "empty :: forall a. Set a",
              "description": "Construct an empty set."
            },
            {
              "name": "member",
              "kind": "function",
              "signature": "member :: forall a. using (ord :: Ord a) => a -> Set a -> Bool",
              "description": "Test whether the set contains a value."
            },
            {
              "name": "union",
              "kind": "function",
              "signature": "union :: forall a. using (ord :: Ord a) => Set a -> Set a -> Set a",
              "description": "Combine two sets, retaining each value once."
            }
          ],
          "imports": []
        },
        {
          "name": "Data.NonEmpty",
          "description": "Collections whose type guarantees at least one element.",
          "declarations": [
            {
              "name": "NonEmpty",
              "kind": "type",
              "signature": "data NonEmpty a",
              "description": "One head element followed by a possibly empty tail.",
              "constructors": [
                {
                  "name": "NonEmpty",
                  "signature": "NonEmpty :: a -> List a -> NonEmpty a",
                  "description": "Construct a nonempty sequence."
                }
              ]
            },
            {
              "name": "head",
              "kind": "function",
              "signature": "head :: forall a. NonEmpty a -> a",
              "description": "Read the first element. No empty case is possible."
            },
            {
              "name": "to-list",
              "kind": "function",
              "signature": "to-list :: forall a. NonEmpty a -> List a",
              "description": "Forget the nonempty guarantee and retain the values."
            }
          ],
          "imports": [
            "Data.List"
          ]
        }
      ],
      "readme": [
        "Persistent maps, sets, and nonempty collections.",
        "Import a module explicitly to use its types and functions. The module reference lists declarations, examples, and links to related types.",
        "This package is part of the sample catalogue used to develop Cinch’s package documentation site."
      ]
    },
    {
      "name": "cinch-text",
      "version": "0.3.0",
      "versions": [
        "0.3.0",
        "0.2.0"
      ],
      "category": "Text",
      "synopsis": "UTF-8 processing and composable text parsers.",
      "description": "UTF-8 processing and composable text parsers.",
      "license": "BSD-3-Clause",
      "maintainer": "Cinch contributors",
      "updated": "2026-10-28",
      "dependencies": [
        "cinch-base"
      ],
      "modules": [
        {
          "name": "Text.Utf8",
          "description": "Decode, encode, and inspect UTF-8 text.",
          "declarations": [
            {
              "name": "Utf8Error",
              "kind": "type",
              "signature": "data Utf8Error",
              "description": "An invalid byte sequence and the offset at which decoding failed."
            },
            {
              "name": "decode",
              "kind": "function",
              "signature": "decode :: Bytes -> Result Utf8Error String",
              "description": "Decode UTF-8 bytes. Invalid sequences produce a structured error."
            },
            {
              "name": "encode",
              "kind": "function",
              "signature": "encode :: String -> Bytes",
              "description": "Encode a string as UTF-8 bytes."
            },
            {
              "name": "lines",
              "kind": "function",
              "signature": "lines :: String -> List String",
              "description": "Split text at line boundaries."
            }
          ],
          "imports": [
            "Prelude",
            "Data.Result",
            "Data.List"
          ]
        },
        {
          "name": "Text.Parser",
          "description": "Small parsers that compose into larger parsers.",
          "declarations": [
            {
              "name": "Parser",
              "kind": "type",
              "signature": "opaque Parser a",
              "description": "A parser that either produces a value or reports a position and expectation."
            },
            {
              "name": "ParseError",
              "kind": "type",
              "signature": "data ParseError",
              "description": "A source position and the expectations that were not met."
            },
            {
              "name": "parse",
              "kind": "function",
              "signature": "parse :: forall a. Parser a -> String -> Result ParseError a",
              "description": "Run a parser and require it to consume the full input."
            },
            {
              "name": "integer",
              "kind": "function",
              "signature": "integer :: Parser Int",
              "description": "Parse a signed decimal integer.",
              "example": "parse integer \"-42\"\n-- Ok (-42)"
            }
          ],
          "imports": [
            "Data.Result"
          ]
        }
      ],
      "readme": [
        "UTF-8 processing and composable text parsers.",
        "Import a module explicitly to use its types and functions. The module reference lists declarations, examples, and links to related types.",
        "This package is part of the sample catalogue used to develop Cinch’s package documentation site."
      ]
    },
    {
      "name": "cinch-json",
      "version": "0.2.4",
      "versions": [
        "0.2.4",
        "0.2.3"
      ],
      "category": "Data",
      "synopsis": "JSON values, typed decoders, and path-aware error messages.",
      "description": "JSON values, typed decoders, and path-aware error messages.",
      "license": "BSD-3-Clause",
      "maintainer": "Cinch contributors",
      "updated": "2026-10-28",
      "dependencies": [
        "cinch-base",
        "cinch-text"
      ],
      "modules": [
        {
          "name": "Data.Json",
          "description": "A JSON value tree and its textual representation.",
          "declarations": [
            {
              "name": "Json",
              "kind": "type",
              "signature": "data Json",
              "description": "A null, boolean, number, string, array, or object value."
            },
            {
              "name": "JsonError",
              "kind": "type",
              "signature": "data JsonError",
              "description": "A byte offset and description of a malformed JSON document."
            },
            {
              "name": "parse",
              "kind": "function",
              "signature": "parse :: String -> Result JsonError Json",
              "description": "Parse a complete JSON document."
            },
            {
              "name": "render",
              "kind": "function",
              "signature": "render :: Json -> String",
              "description": "Render a compact JSON representation."
            }
          ],
          "imports": [
            "Prelude",
            "Data.Result"
          ]
        },
        {
          "name": "Data.Json.Decode",
          "description": "Convert a JSON value to a specific application type.",
          "declarations": [
            {
              "name": "Decoder",
              "kind": "type",
              "signature": "opaque Decoder a",
              "description": "A typed decoder with a path-aware failure report."
            },
            {
              "name": "DecodeError",
              "kind": "type",
              "signature": "data DecodeError",
              "description": "The path, expected type, and actual value at a failed decoding step."
            },
            {
              "name": "decode",
              "kind": "function",
              "signature": "decode :: forall a. Decoder a -> Json -> Result DecodeError a",
              "description": "Apply a decoder to a JSON value."
            },
            {
              "name": "field",
              "kind": "function",
              "signature": "field :: forall a. String -> Decoder a -> Decoder a",
              "description": "Decode a named field in an object."
            },
            {
              "name": "string",
              "kind": "function",
              "signature": "string :: Decoder String",
              "description": "Accept a JSON string."
            }
          ],
          "imports": [
            "Data.Json",
            "Data.Result"
          ]
        }
      ],
      "readme": [
        "JSON values, typed decoders, and path-aware error messages.",
        "Import a module explicitly to use its types and functions. The module reference lists declarations, examples, and links to related types.",
        "This package is part of the sample catalogue used to develop Cinch’s package documentation site."
      ]
    },
    {
      "name": "cinch-http",
      "version": "0.4.0",
      "versions": [
        "0.4.0",
        "0.3.0"
      ],
      "category": "Networking",
      "synopsis": "HTTP request and response types with an effect-explicit client.",
      "description": "HTTP request and response types with an effect-explicit client.",
      "license": "BSD-3-Clause",
      "maintainer": "Cinch contributors",
      "updated": "2026-10-28",
      "dependencies": [
        "cinch-base",
        "cinch-text"
      ],
      "modules": [
        {
          "name": "Net.Http",
          "description": "Shared HTTP message types.",
          "declarations": [
            {
              "name": "Request",
              "kind": "type",
              "signature": "record Request",
              "description": "A request method, URL, headers, and optional body."
            },
            {
              "name": "Response",
              "kind": "type",
              "signature": "record Response",
              "description": "A status code, response headers, and body bytes."
            },
            {
              "name": "HttpError",
              "kind": "type",
              "signature": "data HttpError",
              "description": "A connection, protocol, or timeout failure."
            },
            {
              "name": "status-code",
              "kind": "function",
              "signature": "status-code :: Response -> Nat",
              "description": "Read the numerical HTTP status code."
            }
          ],
          "imports": []
        },
        {
          "name": "Net.Http.Client",
          "description": "An HTTP client whose network operations appear in its effect signature.",
          "declarations": [
            {
              "name": "get",
              "kind": "function",
              "signature": "get :: String ->{Io r} Result HttpError Response",
              "description": "Send a GET request. Connection failures remain explicit in Result.",
              "example": "response <- get \"https://example.com/\"\ncase response of\n  Ok value -> status-code value\n  Err problem -> 0"
            },
            {
              "name": "send",
              "kind": "function",
              "signature": "send :: Request ->{Io r} Result HttpError Response",
              "description": "Send a request with an explicit method, headers, and body."
            },
            {
              "name": "with-timeout",
              "kind": "function",
              "signature": "with-timeout :: Nat -> Request ->{Io r} Result HttpError Response",
              "description": "Send a request with a timeout expressed in milliseconds.",
              "since": "0.4.0"
            }
          ],
          "imports": [
            "Net.Http",
            "Data.Result"
          ]
        }
      ],
      "readme": [
        "HTTP request and response types with an effect-explicit client.",
        "Import a module explicitly to use its types and functions. The module reference lists declarations, examples, and links to related types.",
        "This package is part of the sample catalogue used to develop Cinch’s package documentation site."
      ]
    },
    {
      "name": "cinch-async",
      "version": "0.1.2",
      "versions": [
        "0.1.2",
        "0.1.1"
      ],
      "category": "Concurrency",
      "synopsis": "Scoped tasks and bounded channels with explicit ownership transfer.",
      "description": "Scoped tasks and bounded channels with explicit ownership transfer.",
      "license": "BSD-3-Clause",
      "maintainer": "Cinch contributors",
      "updated": "2026-10-28",
      "dependencies": [
        "cinch-base"
      ],
      "modules": [
        {
          "name": "Control.Task",
          "description": "Tasks whose lifetime is bounded by a surrounding scope.",
          "declarations": [
            {
              "name": "Task",
              "kind": "type",
              "signature": "opaque Task scope a",
              "description": "A handle to a scoped computation. Its result can be joined once."
            },
            {
              "name": "spawn",
              "kind": "function",
              "signature": "spawn :: forall a. (Unit ->{Io r} a) ->{Io r} Task scope a",
              "description": "Start a child computation in the current scope."
            },
            {
              "name": "join",
              "kind": "function",
              "signature": "join :: forall a. Task scope a ->{Io r} a",
              "description": "Wait for a task and consume its result handle."
            }
          ],
          "imports": []
        },
        {
          "name": "Control.Channel",
          "description": "Bounded communication with backpressure.",
          "declarations": [
            {
              "name": "Channel",
              "kind": "type",
              "signature": "opaque Channel a",
              "description": "A bounded channel used to transfer values between tasks."
            },
            {
              "name": "send",
              "kind": "function",
              "signature": "send :: forall a. Channel a -> a ->{Io r} Unit",
              "description": "Send a value, waiting when the channel is full."
            },
            {
              "name": "receive",
              "kind": "function",
              "signature": "receive :: forall a. Channel a ->{Io r} Option a",
              "description": "Receive the next value. A closed channel produces None."
            }
          ],
          "imports": [
            "Data.Option"
          ]
        }
      ],
      "readme": [
        "Scoped tasks and bounded channels with explicit ownership transfer.",
        "Import a module explicitly to use its types and functions. The module reference lists declarations, examples, and links to related types.",
        "This package is part of the sample catalogue used to develop Cinch’s package documentation site."
      ]
    },
    {
      "name": "cinch-time",
      "version": "0.1.0",
      "versions": [
        "0.1.0"
      ],
      "category": "System",
      "synopsis": "Durations, wall-clock instants, and monotonic measurements.",
      "description": "Durations, wall-clock instants, and monotonic measurements.",
      "license": "BSD-3-Clause",
      "maintainer": "Cinch contributors",
      "updated": "2026-10-28",
      "dependencies": [
        "cinch-base"
      ],
      "modules": [
        {
          "name": "Data.Time",
          "description": "Time values with distinct wall-clock and duration types.",
          "declarations": [
            {
              "name": "Duration",
              "kind": "type",
              "signature": "opaque Duration",
              "description": "A nonnegative span of time."
            },
            {
              "name": "Instant",
              "kind": "type",
              "signature": "opaque Instant",
              "description": "A point on the monotonic clock."
            },
            {
              "name": "milliseconds",
              "kind": "function",
              "signature": "milliseconds :: Nat -> Duration",
              "description": "Construct a duration from milliseconds."
            },
            {
              "name": "now",
              "kind": "function",
              "signature": "now :: Unit ->{Io r} Instant",
              "description": "Read the monotonic clock."
            },
            {
              "name": "elapsed",
              "kind": "function",
              "signature": "elapsed :: Instant -> Instant -> Duration",
              "description": "Measure the duration between two instants."
            }
          ],
          "imports": []
        }
      ],
      "readme": [
        "Durations, wall-clock instants, and monotonic measurements.",
        "Import a module explicitly to use its types and functions. The module reference lists declarations, examples, and links to related types.",
        "This package is part of the sample catalogue used to develop Cinch’s package documentation site."
      ]
    },
    {
      "name": "cinch-test",
      "version": "0.3.2",
      "versions": [
        "0.3.2",
        "0.3.1"
      ],
      "category": "Testing",
      "synopsis": "Property checks, generators, and a small test runner.",
      "description": "Property checks, generators, and a small test runner.",
      "license": "BSD-3-Clause",
      "maintainer": "Cinch contributors",
      "updated": "2026-10-28",
      "dependencies": [
        "cinch-base"
      ],
      "modules": [
        {
          "name": "Test.Check",
          "description": "Describe properties and generate input values.",
          "declarations": [
            {
              "name": "Gen",
              "kind": "type",
              "signature": "opaque Gen a",
              "description": "A deterministic generator that produces values from a seed."
            },
            {
              "name": "Property",
              "kind": "type",
              "signature": "opaque Property",
              "description": "A testable proposition with a failure report and counterexample."
            },
            {
              "name": "for-all",
              "kind": "function",
              "signature": "for-all :: forall a. Gen a -> (a -> Bool) -> Property",
              "description": "Test a property over generated values."
            },
            {
              "name": "check",
              "kind": "function",
              "signature": "check :: Nat -> Property ->{Io r} Result String Unit",
              "description": "Run a property for the requested number of examples."
            }
          ],
          "imports": [
            "Data.Result"
          ]
        },
        {
          "name": "Test.Runner",
          "description": "Group tests and report their results.",
          "declarations": [
            {
              "name": "Test",
              "kind": "type",
              "signature": "opaque Test",
              "description": "A named test or group of tests."
            },
            {
              "name": "group",
              "kind": "function",
              "signature": "group :: String -> List Test -> Test",
              "description": "Name a collection of tests."
            },
            {
              "name": "run",
              "kind": "function",
              "signature": "run :: List Test ->{Io r} Nat",
              "description": "Run a test collection and return the number of failures."
            }
          ],
          "imports": [
            "Data.List"
          ]
        }
      ],
      "readme": [
        "Property checks, generators, and a small test runner.",
        "Import a module explicitly to use its types and functions. The module reference lists declarations, examples, and links to related types.",
        "This package is part of the sample catalogue used to develop Cinch’s package documentation site."
      ]
    }
  ]
}