5b1: guarantee the parse direction's position in the type, and name it one level deeper

src/result.ts

@@ -19,16 +19,16 @@ export type ConvertErrorPath = readonly (number | string)[]
 
 export type SourcePosition = { line: number; offset: number }
 
-export type ConvertError = {
+export type ConvertFault = {
   code: ConvertErrorCode
   message: string
-  path: ConvertErrorPath
-  position?: SourcePosition
 }
 
-export type ConvertFault = Omit<ConvertError, 'path' | 'position'>
+export type ConvertError = ConvertFault & { path: ConvertErrorPath; position?: SourcePosition }
 
-export type Result<T> = { error: ConvertError; ok: false } | { ok: true; value: T }
+export type ParseError = ConvertError & { position: SourcePosition }
+
+export type Result<T, E extends ConvertError = ConvertError> = { error: E; ok: false } | { ok: true; value: T }
 
 export function failure<T>(code: ConvertErrorCode, message: string, path: ConvertErrorPath): Result<T> {
   return { error: { code, message, path }, ok: false }
@@ -38,11 +38,11 @@ export function faulted<T>(fault: ConvertFault, path: ConvertErrorPath): Result<
   return failure(fault.code, fault.message, path)
 }
 
-export function positioned<T>(result: Result<T>, position: SourcePosition): Result<T> {
-  if (result.ok || result.error.position !== undefined) return result
-  return { error: { ...result.error, position }, ok: false }
+export function positioned<T>(result: Result<T>, position: SourcePosition): Result<T, ParseError> {
+  if (result.ok) return result
+  return { error: { ...result.error, position: result.error.position ?? position }, ok: false }
 }
 
-export function success<T>(value: T): Result<T> {
+export function success<T>(value: T): { ok: true; value: T } {
   return { ok: true, value }
 }