diff --git a/.clang-format b/.clang-format
index 0b8c0be..86cbf0d 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,17 +1,163 @@
-BasedOnStyle: LLVM
-IndentWidth: 4
-ColumnLimit: 140
-TabWidth: 4
-UseTab: Never
-BreakBeforeBraces: Allman
-AllowShortFunctionsOnASingleLine: Empty
-PointerAlignment: Left
+---
+Language:        Cpp
+# BasedOnStyle:  Microsoft
+AccessModifierOffset: -2
+AlignAfterOpenBracket: BlockIndent
+AlignEscapedNewlines: Right
+AlignOperands:   Align
+AlignTrailingComments: false
+AlignConsecutiveAssignments: true
+AlignConsecutiveDeclarations: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: false
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+AttributeMacros:
+  - __capability
+BinPackArguments: false
+BinPackParameters: AlwaysOnePerLine
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      true
+  AfterControlStatement: Always
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  true
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      false
+  AfterExternBlock: true
+  BeforeCatch:     true
+  BeforeElse:      true
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     120
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
 DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+StatementAttributeLikeMacros:
+  - Q_EMIT
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: false
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequires:  false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 1000
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
-SortIncludes: true
-IncludeBlocks: Regroup
-ReflowComments: true
-ContinuationIndentWidth: 4
-BinPackParameters: false
-BinPackArguments: false
- 
\ No newline at end of file
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        Latest
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        4
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
diff --git a/.clang-tidy b/.clang-tidy
index 6793178..3ddf761 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,30 +1,593 @@
-Checks: >
-  -*,
-  readability-* ,
-  modernize-* ,
-  -modernize-use-trailing-return-type,
-  -readability-magic-numbers,
-
-WarningsAsErrors: >
-  bugprone-* ,
-  performance-* ,
-  clang-analyzer-*
-
-HeaderFilterRegex: 'src/.*'
-FormatStyle: file
-
+---
+Checks:          '*,
+                  -bugprone-easily-swappable-parameters,
+                  -bugprone-lambda-function-name,
+                  -readability-magic-numbers,
+                  -hicpp-no-array-decay,
+                  -hicpp-signed-bitwise,
+                  -hicpp-vararg,
+                  -misc-non-private-member-variables-in-classes,
+                  -cppcoreguidelines-*,
+                  -fuchsia-*,
+                  -altera-*,
+                  -android-*,
+                  -llvmlibc-*,
+                  -readability-convert-member-functions-to-static,
+                  -boost-use-ranges,
+                  -google-objc-function-naming,
+                  -google-objc-global-variable-declaration,
+                  -performance-enum-size'
+WarningsAsErrors: ''
+HeaderFilterRegex: '^(?!magic_enum).*$'
+FormatStyle:     Microsoft
 CheckOptions:
+  - key:             readability-identifier-naming.ClassCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.ClassMemberCase
+    value:           lower_case
+  - key:             readability-identifier-naming.ConstexprVariableCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.ConstexprVariablePrefix
+    value:           k
+  - key:             readability-identifier-naming.EnumCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.EnumConstantCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.EnumConstantPrefix
+    value:           k
+  - key:             readability-identifier-naming.FunctionCase
+    value:           camelBack
+  - key:             readability-identifier-naming.FunctionIgnoredRegexp
+    value:           '^BM_.*$'
+  - key:             readability-identifier-naming.GlobalConstantCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.GlobalConstantPrefix
+    value:           k
+  - key:             readability-identifier-naming.StaticConstantCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.StaticConstantPrefix
+    value:           k
+  - key:             readability-identifier-naming.StaticVariableCase
+    value:           lower_case
+  - key:             readability-identifier-naming.MacroDefinitionCase
+    value:           UPPER_CASE
+  - key:             readability-identifier-naming.MacroDefinitionIgnoredRegexp
+    value:           '^[A-Z]+(_[A-Z]+)*_$'
+  - key:             readability-identifier-naming.MemberCase
+    value:           lower_case
+  - key:             readability-identifier-naming.PrivateMemberSuffix
+    value:           _
+  - key:             readability-identifier-naming.PublicMemberSuffix
+    value:           ''
+  - key:             readability-identifier-naming.NamespaceCase
+    value:           lower_case
+  - key:             readability-identifier-naming.ParameterCase
+    value:           lower_case
+  - key:             readability-identifier-naming.TypeAliasCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.TypedefCase
+    value:           CamelCase
+  - key:             readability-identifier-naming.VariableCase
+    value:           lower_case
+  - key:             readability-identifier-naming.IgnoreMainLikeFunctions
+    value:           'true'
+  - key:             readability-identifier-naming.AggressiveDependentMemberLookup
+    value:           'false'
+  - key:             readability-identifier-naming.IgnoreFailedSplit
+    value:           'false'
+  - key:             abseil-string-find-startswith.AbseilStringsMatchHeader
+    value:           'absl/strings/match.h'
+  - key:             abseil-string-find-startswith.IncludeStyle
+    value:           llvm
+  - key:             abseil-string-find-startswith.StringLikeClasses
+    value:           '::std::basic_string'
+  - key:             abseil-string-find-str-contains.AbseilStringsMatchHeader
+    value:           'absl/strings/match.h'
+  - key:             abseil-string-find-str-contains.IncludeStyle
+    value:           llvm
+  - key:             abseil-string-find-str-contains.StringLikeClasses
+    value:           '::std::basic_string;::std::basic_string_view;::absl::string_view'
+  - key:             bugprone-argument-comment.CommentBoolLiterals
+    value:           '0'
+  - key:             bugprone-argument-comment.CommentCharacterLiterals
+    value:           '0'
+  - key:             bugprone-argument-comment.CommentFloatLiterals
+    value:           '0'
+  - key:             bugprone-argument-comment.CommentIntegerLiterals
+    value:           '0'
+  - key:             bugprone-argument-comment.CommentNullPtrs
+    value:           '0'
+  - key:             bugprone-argument-comment.CommentStringLiterals
+    value:           '0'
+  - key:             bugprone-argument-comment.CommentUserDefinedLiterals
+    value:           '0'
+  - key:             bugprone-argument-comment.IgnoreSingleArgument
+    value:           '0'
+  - key:             bugprone-argument-comment.StrictMode
+    value:           '0'
+  - key:             bugprone-assert-side-effect.AssertMacros
+    value:           assert
+  - key:             bugprone-assert-side-effect.CheckFunctionCalls
+    value:           'false'
+  - key:             bugprone-dangling-handle.HandleClasses
+    value:           'std::basic_string_view;std::experimental::basic_string_view'
+  - key:             bugprone-dynamic-static-initializers.HeaderFileExtensions
+    value:           ';h;hh;hpp;hxx'
+  - key:             bugprone-exception-escape.FunctionsThatShouldNotThrow
+    value:           ''
+  - key:             bugprone-exception-escape.IgnoredExceptions
+    value:           ''
+  - key:             bugprone-misplaced-widening-cast.CheckImplicitCasts
+    value:           'false'
+  - key:             bugprone-narrowing-conversions.PedanticMode
+    value:           'false'
+  - key:             bugprone-narrowing-conversions.WarnOnFloatingPointNarrowingConversion
+    value:           'true'
+  - key:             bugprone-not-null-terminated-result.WantToUseSafeFunctions
+    value:           'true'
+  - key:             bugprone-reserved-identifier.AggressiveDependentMemberLookup
+    value:           'false'
+  - key:             bugprone-reserved-identifier.AllowedIdentifiers
+    value:           ''
+  - key:             bugprone-reserved-identifier.Invert
+    value:           'false'
+  - key:             bugprone-signed-char-misuse.CharTypdefsToIgnore
+    value:           ''
+  - key:             bugprone-signed-char-misuse.DiagnoseSignedUnsignedCharComparisons
+    value:           'true'
+  - key:             bugprone-sizeof-expression.WarnOnSizeOfCompareToConstant
+    value:           'true'
+  - key:             bugprone-sizeof-expression.WarnOnSizeOfConstant
+    value:           'true'
+  - key:             bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression
+    value:           'false'
+  - key:             bugprone-sizeof-expression.WarnOnSizeOfThis
+    value:           'true'
+  - key:             bugprone-string-constructor.LargeLengthThreshold
+    value:           '8388608'
+  - key:             bugprone-string-constructor.WarnOnLargeLength
+    value:           'true'
+  - key:             bugprone-suspicious-enum-usage.StrictMode
+    value:           'false'
+  - key:             bugprone-suspicious-include.HeaderFileExtensions
+    value:           ';h;hh;hpp;hxx'
+  - key:             bugprone-suspicious-include.ImplementationFileExtensions
+    value:           'c;cc;cpp;cxx'
+  - key:             bugprone-suspicious-missing-comma.MaxConcatenatedTokens
+    value:           '5'
+  - key:             bugprone-suspicious-missing-comma.RatioThreshold
+    value:           '0.200000'
+  - key:             bugprone-suspicious-missing-comma.SizeThreshold
+    value:           '5'
+  - key:             bugprone-suspicious-string-compare.StringCompareLikeFunctions
+    value:           ''
+  - key:             bugprone-suspicious-string-compare.WarnOnImplicitComparison
+    value:           'true'
+  - key:             bugprone-suspicious-string-compare.WarnOnLogicalNotComparison
+    value:           'false'
+  - key:             bugprone-too-small-loop-variable.MagnitudeBitsUpperLimit
+    value:           '16'
+  - key:             bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField
+    value:           'true'
+  - key:             bugprone-unused-return-value.CheckedFunctions
+    value:           '::std::async;::std::launder;::std::remove;::std::remove_if;::std::unique;::std::unique_ptr::release;::std::basic_string::empty;::std::vector::empty;::std::back_inserter;::std::distance;::std::find;::std::find_if;::std::inserter;::std::lower_bound;::std::make_pair;::std::map::count;::std::map::find;::std::map::lower_bound;::std::multimap::equal_range;::std::multimap::upper_bound;::std::set::count;::std::set::find;::std::setfill;::std::setprecision;::std::setw;::std::upper_bound;::std::vector::at;::bsearch;::ferror;::feof;::isalnum;::isalpha;::isblank;::iscntrl;::isdigit;::isgraph;::islower;::isprint;::ispunct;::isspace;::isupper;::iswalnum;::iswprint;::iswspace;::isxdigit;::memchr;::memcmp;::strcmp;::strcoll;::strncmp;::strpbrk;::strrchr;::strspn;::strstr;::wcscmp;::access;::bind;::connect;::difftime;::dlsym;::fnmatch;::getaddrinfo;::getopt;::htonl;::htons;::iconv_open;::inet_addr;::isascii;::isatty;::mmap;::newlocale;::openat;::pathconf;::pthread_equal;::pthread_getspecific;::pthread_mutex_trylock;::readdir;::readlink;::recvmsg;::regexec;::scandir;::semget;::setjmp;::shm_open;::shmget;::sigismember;::strcasecmp;::strsignal;::ttyname'
+  - key:             cert-dcl16-c.IgnoreMacros
+    value:           'true'
+  - key:             cert-dcl16-c.NewSuffixes
+    value:           'L;LL;LU;LLU'
+  - key:             cert-dcl37-c.AggressiveDependentMemberLookup
+    value:           'false'
+  - key:             cert-dcl37-c.AllowedIdentifiers
+    value:           ''
+  - key:             cert-dcl37-c.Invert
+    value:           'false'
+  - key:             cert-dcl51-cpp.AggressiveDependentMemberLookup
+    value:           'false'
+  - key:             cert-dcl51-cpp.AllowedIdentifiers
+    value:           ''
+  - key:             cert-dcl51-cpp.Invert
+    value:           'false'
+  - key:             cert-dcl59-cpp.HeaderFileExtensions
+    value:           ';h;hh;hpp;hxx'
+  - key:             cert-err09-cpp.CheckThrowTemporaries
+    value:           'true'
+  - key:             cert-err09-cpp.MaxSize
+    value:           '-1'
+  - key:             cert-err09-cpp.WarnOnLargeObjects
+    value:           'false'
+  - key:             cert-err61-cpp.CheckThrowTemporaries
+    value:           'true'
+  - key:             cert-err61-cpp.MaxSize
+    value:           '-1'
+  - key:             cert-err61-cpp.WarnOnLargeObjects
+    value:           'false'
+  - key:             cert-msc32-c.DisallowedSeedTypes
+    value:           'time_t,std::time_t'
+  - key:             cert-msc51-cpp.DisallowedSeedTypes
+    value:           'time_t,std::time_t'
+  - key:             cert-oop11-cpp.IncludeStyle
+    value:           llvm
+  - key:             cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+    value:           'false'
+  - key:             cert-oop57-cpp.MemCmpNames
+    value:           ''
+  - key:             cert-oop57-cpp.MemCpyNames
+    value:           ''
+  - key:             cert-oop57-cpp.MemSetNames
+    value:           ''
+  - key:             cert-str34-c.CharTypdefsToIgnore
+    value:           ''
+  - key:             cert-str34-c.DiagnoseSignedUnsignedCharComparisons
+    value:           'false'
+  - key:             cppcoreguidelines-avoid-magic-numbers.IgnoreAllFloatingPointValues
+    value:           'false'
+  - key:             cppcoreguidelines-avoid-magic-numbers.IgnoreBitFieldsWidths
+    value:           'true'
+  - key:             cppcoreguidelines-avoid-magic-numbers.IgnorePowersOf2IntegerValues
+    value:           'false'
+  - key:             cppcoreguidelines-avoid-magic-numbers.IgnoredFloatingPointValues
+    value:           '1.0;100.0;'
+  - key:             cppcoreguidelines-avoid-magic-numbers.IgnoredIntegerValues
+    value:           '1;2;3;4;'
+  - key:             cppcoreguidelines-explicit-virtual-functions.AllowOverrideAndFinal
+    value:           'false'
+  - key:             cppcoreguidelines-explicit-virtual-functions.FinalSpelling
+    value:           final
+  - key:             cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
+    value:           'true'
+  - key:             cppcoreguidelines-explicit-virtual-functions.OverrideSpelling
+    value:           override
+  - key:             cppcoreguidelines-init-variables.IncludeStyle
+    value:           llvm
+  - key:             cppcoreguidelines-init-variables.MathHeader
+    value:           math.h
+  - key:             cppcoreguidelines-macro-usage.AllowedRegexp
+    value:           '^DEBUG_*'
+  - key:             cppcoreguidelines-macro-usage.CheckCapsOnly
+    value:           'false'
+  - key:             cppcoreguidelines-macro-usage.IgnoreCommandLineMacros
+    value:           'true'
+  - key:             cppcoreguidelines-narrowing-conversions.PedanticMode
+    value:           'false'
+  - key:             cppcoreguidelines-narrowing-conversions.WarnOnFloatingPointNarrowingConversion
+    value:           'true'
+  - key:             cppcoreguidelines-no-malloc.Allocations
+    value:           '::malloc;::calloc'
+  - key:             cppcoreguidelines-no-malloc.Deallocations
+    value:           '::free'
+  - key:             cppcoreguidelines-no-malloc.Reallocations
+    value:           '::realloc'
+  - key:             cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value:           'true'
+  - key:             cppcoreguidelines-non-private-member-variables-in-classes.IgnorePublicMemberVariables
+    value:           'false'
+  - key:             cppcoreguidelines-owning-memory.LegacyResourceConsumers
+    value:           '::free;::realloc;::freopen;::fclose'
+  - key:             cppcoreguidelines-owning-memory.LegacyResourceProducers
+    value:           '::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile'
+  - key:             cppcoreguidelines-pro-bounds-constant-array-index.GslHeader
+    value:           ''
+  - key:             cppcoreguidelines-pro-bounds-constant-array-index.IncludeStyle
+    value:           llvm
+  - key:             cppcoreguidelines-pro-type-member-init.IgnoreArrays
+    value:           'false'
+  - key:             cppcoreguidelines-pro-type-member-init.UseAssignment
+    value:           'false'
+  - key:             cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions
+    value:           'false'
+  - key:             cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted
+    value:           'false'
+  - key:             cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor
+    value:           'false'
+  - key:             google-build-namespaces.HeaderFileExtensions
+    value:           ';h;hh;hpp;hxx'
+  - key:             google-global-names-in-headers.HeaderFileExtensions
+    value:           ';h;hh;hpp;hxx'
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '1'
+  - key:             google-readability-function-size.BranchThreshold
+    value:           '4294967295'
+  - key:             google-readability-function-size.LineThreshold
+    value:           '4294967295'
+  - key:             google-readability-function-size.NestingThreshold
+    value:           '4294967295'
+  - key:             google-readability-function-size.ParameterThreshold
+    value:           '4294967295'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             google-readability-function-size.VariableThreshold
+    value:           '4294967295'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             google-runtime-int.SignedTypePrefix
+    value:           int
+  - key:             google-runtime-int.TypeSuffix
+    value:           ''
+  - key:             google-runtime-int.UnsignedTypePrefix
+    value:           uint
+  - key:             google-runtime-references.IncludedTypes
+    value:           ''
+  - key:             hicpp-braces-around-statements.ShortStatementLines
+    value:           '0'
+  - key:             hicpp-function-size.BranchThreshold
+    value:           '4294967295'
+  - key:             hicpp-function-size.LineThreshold
+    value:           '4294967295'
+  - key:             hicpp-function-size.NestingThreshold
+    value:           '4294967295'
+  - key:             hicpp-function-size.ParameterThreshold
+    value:           '4294967295'
+  - key:             hicpp-function-size.StatementThreshold
+    value:           '800'
+  - key:             hicpp-function-size.VariableThreshold
+    value:           '4294967295'
+  - key:             hicpp-member-init.IgnoreArrays
+    value:           'false'
+  - key:             hicpp-member-init.UseAssignment
+    value:           'false'
+  - key:             hicpp-move-const-arg.CheckTriviallyCopyableMove
+    value:           'true'
+  - key:             hicpp-multiway-paths-covered.WarnOnMissingElse
+    value:           'false'
+  - key:             hicpp-no-malloc.Allocations
+    value:           '::malloc;::calloc'
+  - key:             hicpp-no-malloc.Deallocations
+    value:           '::free'
+  - key:             hicpp-no-malloc.Reallocations
+    value:           '::realloc'
+  - key:             hicpp-signed-bitwise.IgnorePositiveIntegerLiterals
+    value:           'false'
+  - key:             hicpp-special-member-functions.AllowMissingMoveFunctions
+    value:           'false'
+  - key:             hicpp-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted
+    value:           'false'
+  - key:             hicpp-special-member-functions.AllowSoleDefaultDtor
+    value:           'false'
+  - key:             hicpp-uppercase-literal-suffix.IgnoreMacros
+    value:           'true'
+  - key:             hicpp-uppercase-literal-suffix.NewSuffixes
+    value:           ''
+  - key:             hicpp-use-auto.MinTypeNameLength
+    value:           '5'
+  - key:             hicpp-use-auto.RemoveStars
+    value:           'false'
+  - key:             hicpp-use-emplace.ContainersWithPushBack
+    value:           '::std::vector;::std::list;::std::deque'
+  - key:             hicpp-use-emplace.IgnoreImplicitConstructors
+    value:           'false'
+  - key:             hicpp-use-emplace.SmartPointers
+    value:           '::std::shared_ptr;::std::unique_ptr;::std::auto_ptr;::std::weak_ptr'
+  - key:             hicpp-use-emplace.TupleMakeFunctions
+    value:           '::std::make_pair;::std::make_tuple'
+  - key:             hicpp-use-emplace.TupleTypes
+    value:           '::std::pair;::std::tuple'
+  - key:             hicpp-use-equals-default.IgnoreMacros
+    value:           'true'
+  - key:             hicpp-use-equals-delete.IgnoreMacros
+    value:           'true'
+  - key:             hicpp-use-noexcept.ReplacementString
+    value:           ''
+  - key:             hicpp-use-noexcept.UseNoexceptFalse
+    value:           'true'
+  - key:             hicpp-use-nullptr.NullMacros
+    value:           ''
+  - key:             hicpp-use-override.AllowOverrideAndFinal
+    value:           'false'
+  - key:             hicpp-use-override.FinalSpelling
+    value:           final
+  - key:             hicpp-use-override.IgnoreDestructors
+    value:           'false'
+  - key:             hicpp-use-override.OverrideSpelling
+    value:           override
+  - key:             llvm-else-after-return.WarnOnConditionVariables
+    value:           'false'
+  - key:             llvm-else-after-return.WarnOnUnfixable
+    value:           'false'
+  - key:             llvm-header-guard.HeaderFileExtensions
+    value:           ';h;hh;hpp;hxx'
+  - key:             llvm-namespace-comment.ShortNamespaceLines
+    value:           '1'
+  - key:             llvm-namespace-comment.SpacesBeforeComments
+    value:           '1'
+  - key:             llvm-qualified-auto.AddConstToQualified
+    value:           'false'
+  - key:             misc-definitions-in-headers.HeaderFileExtensions
+    value:           ';h;hh;hpp;hxx'
+  - key:             misc-definitions-in-headers.UseHeaderFileExtension
+    value:           'true'
+  - key:             misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value:           'false'
+  - key:             misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables
+    value:           'false'
+  - key:             misc-throw-by-value-catch-by-reference.CheckThrowTemporaries
+    value:           'true'
+  - key:             misc-throw-by-value-catch-by-reference.MaxSize
+    value:           '-1'
+  - key:             misc-throw-by-value-catch-by-reference.WarnOnLargeObjects
+    value:           'false'
+  - key:             misc-unused-parameters.StrictMode
+    value:           'false'
+  - key:             modernize-avoid-bind.PermissiveParameterList
+    value:           'false'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             modernize-make-shared.IgnoreMacros
+    value:           'true'
+  - key:             modernize-make-shared.IncludeStyle
+    value:           llvm
+  - key:             modernize-make-shared.MakeSmartPtrFunction
+    value:           'std::make_shared'
+  - key:             modernize-make-shared.MakeSmartPtrFunctionHeader
+    value:           memory
+  - key:             modernize-make-unique.IgnoreMacros
+    value:           'true'
+  - key:             modernize-make-unique.IncludeStyle
+    value:           llvm
+  - key:             modernize-make-unique.MakeSmartPtrFunction
+    value:           'std::make_unique'
+  - key:             modernize-make-unique.MakeSmartPtrFunctionHeader
+    value:           memory
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             modernize-pass-by-value.ValuesOnly
+    value:           'false'
+  - key:             modernize-raw-string-literal.DelimiterStem
+    value:           lit
+  - key:             modernize-raw-string-literal.ReplaceShorterLiterals
+    value:           'false'
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             modernize-replace-disallow-copy-and-assign-macro.MacroName
+    value:           DISALLOW_COPY_AND_ASSIGN
+  - key:             modernize-replace-random-shuffle.IncludeStyle
+    value:           llvm
   - key:             modernize-use-auto.MinTypeNameLength
     value:           '5'
   - key:             modernize-use-auto.RemoveStars
     value:           'false'
-  - key:             readability-identifier-naming.VariableCase
-    value:           lower_case
-  - key:             readability-identifier-naming.MemberCase
-    value:           lower_case
-  - key:             readability-identifier-naming.PrivateMemberPrefix
-    value:           '_'
-  - key:             readability-function-size.ParameterThreshold
-    value:           '8'
+  - key:             modernize-use-bool-literals.IgnoreMacros
+    value:           'true'
+  - key:             modernize-use-default-member-init.IgnoreMacros
+    value:           'true'
+  - key:             modernize-use-default-member-init.UseAssignment
+    value:           'false'
+  - key:             modernize-use-emplace.ContainersWithPushBack
+    value:           '::std::vector;::std::list;::std::deque'
+  - key:             modernize-use-emplace.IgnoreImplicitConstructors
+    value:           'false'
+  - key:             modernize-use-emplace.SmartPointers
+    value:           '::std::shared_ptr;::std::unique_ptr;::std::auto_ptr;::std::weak_ptr'
+  - key:             modernize-use-emplace.TupleMakeFunctions
+    value:           '::std::make_pair;::std::make_tuple'
+  - key:             modernize-use-emplace.TupleTypes
+    value:           '::std::pair;::std::tuple'
+  - key:             modernize-use-equals-default.IgnoreMacros
+    value:           'true'
+  - key:             modernize-use-equals-delete.IgnoreMacros
+    value:           'true'
+  - key:             modernize-use-nodiscard.ReplacementString
+    value:           '[[nodiscard]]'
+  - key:             modernize-use-noexcept.ReplacementString
+    value:           ''
+  - key:             modernize-use-noexcept.UseNoexceptFalse
+    value:           'true'
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+  - key:             modernize-use-override.AllowOverrideAndFinal
+    value:           'false'
+  - key:             modernize-use-override.FinalSpelling
+    value:           final
+  - key:             modernize-use-override.IgnoreDestructors
+    value:           'false'
+  - key:             modernize-use-override.OverrideSpelling
+    value:           override
+  - key:             modernize-use-transparent-functors.SafeMode
+    value:           'false'
+  - key:             modernize-use-using.IgnoreMacros
+    value:           'true'
+  - key:             objc-forbidden-subclassing.ForbiddenSuperClassNames
+    value:           'ABNewPersonViewController;ABPeoplePickerNavigationController;ABPersonViewController;ABUnknownPersonViewController;NSHashTable;NSMapTable;NSPointerArray;NSPointerFunctions;NSTimer;UIActionSheet;UIAlertView;UIImagePickerController;UITextInputMode;UIWebView'
+  - key:             openmp-exception-escape.IgnoredExceptions
+    value:           ''
+  - key:             performance-faster-string-find.StringLikeClasses
+    value:           '::std::basic_string;::std::basic_string_view'
+  - key:             performance-for-range-copy.AllowedTypes
+    value:           ''
+  - key:             performance-for-range-copy.WarnOnAllAutoCopies
+    value:           'false'
+  - key:             performance-inefficient-string-concatenation.StrictMode
+    value:           'false'
+  - key:             performance-inefficient-vector-operation.EnableProto
+    value:           'false'
+  - key:             performance-inefficient-vector-operation.VectorLikeClasses
+    value:           '::std::vector'
+  - key:             performance-move-const-arg.CheckTriviallyCopyableMove
+    value:           'true'
+  - key:             performance-move-constructor-init.IncludeStyle
+    value:           llvm
+  - key:             performance-no-automatic-move.AllowedTypes
+    value:           ''
+  - key:             performance-type-promotion-in-math-fn.IncludeStyle
+    value:           llvm
+  - key:             performance-unnecessary-copy-initialization.AllowedTypes
+    value:           ''
+  - key:             performance-unnecessary-value-param.AllowedTypes
+    value:           ''
+  - key:             performance-unnecessary-value-param.IncludeStyle
+    value:           llvm
+  - key:             portability-restrict-system-includes.Includes
+    value:           '*'
+  - key:             portability-simd-intrinsics.Std
+    value:           ''
+  - key:             portability-simd-intrinsics.Suggest
+    value:           '0'
   - key:             readability-braces-around-statements.ShortStatementLines
     value:           '0'
+  - key:             readability-else-after-return.WarnOnConditionVariables
+    value:           'true'
+  - key:             readability-else-after-return.WarnOnUnfixable
+    value:           'true'
+  - key:             readability-function-size.BranchThreshold
+    value:           '4294967295'
+  - key:             readability-function-size.LineThreshold
+    value:           '4294967295'
+  - key:             readability-function-size.NestingThreshold
+    value:           '4294967295'
+  - key:             readability-function-size.ParameterThreshold
+    value:           '4294967295'
+  - key:             readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             readability-function-size.VariableThreshold
+    value:           '4294967295'
+  - key:             readability-implicit-bool-conversion.AllowIntegerConditions
+    value:           'false'
+  - key:             readability-implicit-bool-conversion.AllowPointerConditions
+    value:           'false'
+  - key:             readability-inconsistent-declaration-parameter-name.IgnoreMacros
+    value:           'true'
+  - key:             readability-inconsistent-declaration-parameter-name.Strict
+    value:           'false'
+  - key:             readability-magic-numbers.IgnoreAllFloatingPointValues
+    value:           'false'
+  - key:             readability-magic-numbers.IgnoreBitFieldsWidths
+    value:           'true'
+  - key:             readability-magic-numbers.IgnorePowersOf2IntegerValues
+    value:           'false'
+  - key:             readability-magic-numbers.IgnoredFloatingPointValues
+    value:           '1.0;100.0;'
+  - key:             readability-magic-numbers.IgnoredIntegerValues
+    value:           '1;2;3;4;'
+  - key:             readability-qualified-auto.AddConstToQualified
+    value:           'true'
+  - key:             readability-redundant-declaration.IgnoreMacros
+    value:           'true'
+  - key:             readability-redundant-member-init.IgnoreBaseInCopyConstructors
+    value:           'false'
+  - key:             readability-redundant-smartptr-get.IgnoreMacros
+    value:           'true'
+  - key:             readability-redundant-string-init.StringNames
+    value:           '::std::basic_string'
+  - key:             readability-simplify-boolean-expr.ChainedConditionalAssignment
+    value:           'false'
+  - key:             readability-simplify-boolean-expr.ChainedConditionalReturn
+    value:           'false'
+  - key:             readability-simplify-subscript-expr.Types
+    value:           '::std::basic_string;::std::basic_string_view;::std::vector;::std::array'
+  - key:             readability-static-accessed-through-instance.NameSpecifierNestingThreshold
+    value:           '3'
+  - key:             readability-uppercase-literal-suffix.IgnoreMacros
+    value:           'true'
+  - key:             readability-uppercase-literal-suffix.NewSuffixes
+    value:           ''
+  - key:             zircon-temporary-objects.Names
+    value:           ''
+# allow x,y,z single letter names, to be used for coordinates
+  - key:             readability-identifier-length.IgnoredVariableNames
+    value:           '^[xyz]|m0|m1|_$'
+...
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2a66b50..571733f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,4 +1,4 @@
-name: Build & Release CPP-Unix-Bindings
+name: Build & Release cpp_unix_bindings
 
 on:
   push:
@@ -12,34 +12,24 @@ jobs:
   build:
     name: Build shared library
     runs-on: ubuntu-latest
-    env:
-      CC: clang
-      CXX: clang++
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v3
 
-      - name: Install build dependencies
+      - name: Build in manylinux2014 container
         run: |
-          sudo apt-get update
-          sudo apt-get install -y build-essential cmake clang make
-
-      - name: Configure CMake
-        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
-
-      - name: Compile
-        run: cmake --build build -j $(nproc)
+          docker run --rm -v "${{ github.workspace }}:/project" -w /project quay.io/pypa/manylinux2014_x86_64 /bin/bash -c "yum install -y cmake3 devtoolset-11-gcc devtoolset-11-gcc-c++ && ln -sf /usr/bin/cmake3 /usr/bin/cmake && source /opt/rh/devtoolset-11/enable && cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j\$(nproc)"
 
       - name: Upload library artifact
         uses: actions/upload-artifact@v4
         with:
-          name: libCPP-Unix-Bindings
-          path: build/libCPP-Unix-Bindings.so
+          name: libcpp_unix_bindings
+          path: build/libcpp_unix_bindings.so
           retention-days: 14
 
       - name: Attach library to release
         if: github.event_name == 'release'
         uses: softprops/action-gh-release@v1
         with:
-          files: build/libCPP-Unix-Bindings.so 
+          files: build/libcpp_unix_bindings.so 
diff --git a/.gitignore b/.gitignore
index f80d786..33bb172 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,5 @@
 .vscode/
 build/
-src/version_config.cpp
+src/version_config.h
 .cache/
 compile_commands.json
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e1886b7..5d00efa 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,105 +1,72 @@
 cmake_minimum_required(VERSION 3.30)
 
-set(VERSION_MAJOR 0)
-set(VERSION_MINOR 2)
-set(VERSION_PATCH 0)
+project(cpp_unix_bindings VERSION 1.0.0 LANGUAGES CXX)
 
-set(PROJECT_N CPP-Unix-Bindings)
-project(${PROJECT_N} VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
+# Ensure position-independent code for all targets (required for shared libraries)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Always use pthread
+add_link_options(-pthread)
+add_compile_options(-pthread)
 
 # Generate compile_commands.json for clang-based tooling (clangd / clang-tidy)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
+# C++ standard
+set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 include(cmake/CPM.cmake)
 
+# Dependencies
 CPMAddPackage(
-    NAME "googletest"
-    GITHUB_REPOSITORY "google/googletest"
-    GIT_TAG "v1.17.0"
+    NAME googletest
+    GITHUB_REPOSITORY google/googletest
+    GIT_TAG v1.17.0
     GIT_SHALLOW TRUE
-    OPTIONS "GTEST_BUILD_TESTS OFF"
-    OPTIONS "GTEST_BUILD_EXAMPLES OFF"
-    OPTIONS "GTEST_BUILD_DOCS OFF"
+    OPTIONS
+    "GTEST_BUILD_TESTS OFF"
+    "GTEST_BUILD_EXAMPLES OFF"
+    "GTEST_BUILD_DOCS OFF"
 )
 
-# Ensure clang tooling can pick up compile_commands.json from project root
-if(CMAKE_EXPORT_COMPILE_COMMANDS)
-    add_custom_target(copy-compile-commands ALL
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-            ${CMAKE_BINARY_DIR}/compile_commands.json
-            ${PROJECT_SOURCE_DIR}/compile_commands.json
-        COMMENT "Copy compile_commands.json to project root" 
-        VERBATIM)
-endif()
-
-set(CMAKE_CXX_STANDARD 23)
-set(CMAKE_CXX_STANDARD_REQUIRED True)
-
-file(GLOB_RECURSE SRCS ${PROJECT_SOURCE_DIR}/src/**.cpp)
-
-set(LIB true)
-
-configure_file(versioning/version_config.cpp.in ${PROJECT_SOURCE_DIR}/src/version_config.cpp)
-
-# a macro that gets all of the header containing directories. 
-MACRO(header_directories return_list includes_base_folder extention )
-    FILE(GLOB_RECURSE new_list ${includes_base_folder}/*.${extention})
-    SET(dir_list "")
-    FOREACH(file_path ${new_list})
-        GET_FILENAME_COMPONENT(dir_path ${file_path} PATH)
-        SET(dir_list ${dir_list} ${dir_path})
-    ENDFOREACH()
-    LIST(REMOVE_DUPLICATES dir_list)
-    SET(${return_list} ${dir_list})
-ENDMACRO()
-
-# using said macro.
-header_directories(INCLUDES ${PROJECT_SOURCE_DIR}/src/ hpp)
-
-message("src files:")
-foreach(file ${SRCS})
-        message(STATUS ${file})
-endforeach()
-
-message("include directories:")
-foreach(dir ${INCLUDES})
-        message(STATUS ${dir})
-endforeach()
-
-if(LIB)
-    add_library(${PROJECT_N} SHARED ${SRCS})
-else()
-    add_executable(${PROJECT_N} ${SRCS}) 
-endif(LIB)
+CPMAddPackage(
+    NAME cpp_core
+    GITHUB_REPOSITORY Serial-IO/cpp-core
+    GIT_TAG revamp-project
+)
 
-set_target_properties(${PROJECT_N} PROPERTIES 
-                              VERSION ${PROJECT_VERSION}
-                            SOVERSION ${PROJECT_VERSION_MAJOR})
+# Collect all source files
+file(GLOB_RECURSE SRCS ${PROJECT_SOURCE_DIR}/src/*.cpp)
 
-target_include_directories(${PROJECT_N} PUBLIC ${PROJECT_SOURCE_DIR}/src)
+# Main library
+add_library(${PROJECT_NAME} SHARED ${SRCS})
 
-add_executable(serial_integration_tests tests/serial_test.cpp)
-target_link_libraries(serial_integration_tests PRIVATE ${PROJECT_N} gtest_main)
+target_link_libraries(${PROJECT_NAME} PRIVATE cpp_core)
+target_include_directories(${PROJECT_NAME} PUBLIC ${PROJECT_SOURCE_DIR}/src)
 
-target_include_directories(serial_integration_tests PRIVATE ${PROJECT_SOURCE_DIR}/src)
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    VERSION ${PROJECT_VERSION}
+    SOVERSION ${PROJECT_VERSION_MAJOR}
+)
 
-add_custom_command(TARGET serial_integration_tests POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different
-            $<TARGET_FILE:${PROJECT_N}>
-            $<TARGET_FILE_DIR:serial_integration_tests>
-    COMMENT "Copy shared library next to test binary")
+# Test executable
+add_executable(tests
+    tests/serial_test.cpp
+    tests/serial_unit_tests.cpp
+)
 
-# Unit test target covering additional API aspects
-add_executable(serial_unit_tests tests/serial_unit_tests.cpp)
-target_link_libraries(serial_unit_tests PRIVATE ${PROJECT_N} gtest_main)
-target_include_directories(serial_unit_tests PRIVATE ${PROJECT_SOURCE_DIR}/src)
+target_link_libraries(tests PRIVATE ${PROJECT_NAME} gtest cpp_core)
+target_include_directories(tests PRIVATE ${PROJECT_SOURCE_DIR}/src)
 
-add_custom_command(TARGET serial_unit_tests POST_BUILD
+# Copy shared library next to test binary
+add_custom_command(TARGET tests POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E copy_if_different
-            $<TARGET_FILE:${PROJECT_N}>
-            $<TARGET_FILE_DIR:serial_unit_tests>
-    COMMENT "Copy shared library next to unit test binary")
+    $<TARGET_FILE:${PROJECT_NAME}>
+    $<TARGET_FILE_DIR:tests>
+    COMMENT "Copy shared library next to test binary"
+)
 
+# Testing
 enable_testing()
-add_test(NAME SerialEchoTest COMMAND serial_integration_tests /dev/ttyUSB0)
-add_test(NAME SerialUnitTests COMMAND serial_unit_tests)
+add_test(NAME AllTests COMMAND tests /dev/ttyUSB0)
diff --git a/README.md b/README.md
index 3e4d0c0..2d50175 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
-# CPP-Unix-Bindings
+# cpp_unix_bindings
 
 A compact C++23 library for talking to serial devices on Linux (e.g. Arduino).  
-The project builds a **shared library `libCPP-Unix-Bindings.so`** that can be used via
+The project builds a **shared library `libcpp_unix_bindings.so`** that can be used via
 Deno's native FFI.
 
 ---
@@ -21,7 +21,7 @@ cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
 cmake --build build -j
 
 # The resulting library will be located at
-#   build/libCPP-Unix-Bindings.so
+#   build/libcpp_unix_bindings.so
 ```
 
 > Because `CMAKE_EXPORT_COMPILE_COMMANDS` is enabled, the build also generates a
@@ -36,7 +36,7 @@ Deno ships with a first-class FFI API.
 
 ```ts
 // serial_deno.ts
-const lib = Deno.dlopen('./build/libCPP-Unix-Bindings.so', {
+const lib = Deno.dlopen('./build/libcpp_unix_bindings.so', {
   serialOpen: { parameters: [ 'buffer', 'i32', 'i32', 'i32', 'i32' ], result: 'pointer' },
   serialClose: { parameters: [ 'pointer' ], result: 'void' },
   serialRead: { parameters: [ 'pointer', 'buffer', 'i32', 'i32', 'i32' ], result: 'i32' },
@@ -64,16 +64,72 @@ lib.close();
 
 ## 3  C API reference
 
-| Function | Description |
-|----------|-------------|
-| `intptr_t serialOpen(const char* dev, int baud, int bits, int parity, int stop)` | Open a device and return a handle. |
-| `void serialClose(intptr_t handle)` | Close the port. |
-| `int serialRead(...)` | Read bytes with timeout. |
-| `int serialWrite(...)` | Write bytes with timeout. |
-| `int serialGetPortsInfo(char* buffer, int len, const char* sep)` | List ports under `/dev/serial/by-id`. |
-| `void serialOnError(void (*)(int))` | Register an error callback. |
-| *(others in `serial.h`)* |
-
-Return values ≤ 0 indicate error codes defined in `status_codes.h`.
+Below is a condensed overview of the most relevant functions. See `serial.h` for full
+signatures and additional helpers.
+
+### Connection
+* `serialOpen(...)` – open a serial device and return a handle
+* `serialClose(handle)` – close the device
+
+### I/O
+* `serialRead(...)` / `serialWrite(...)` – basic read/write with timeout
+* `serialReadUntil(...)` – read until a specific char is encountered (inclusive)
+* `serialReadLine(...)` – read until `\n`
+* `serialWriteLine(...)` – write buffer and append `\n`
+* `serialReadUntilToken(...)` – read until a string token is encountered
+* `serialReadFrame(...)` – read a frame delimited by start & end bytes
+
+### Helpers
+* `serialPeek(...)` – look at the next byte without consuming it
+* `serialDrain(...)` – wait until all TX bytes are sent
+* `serialClearBufferIn/Out(...)` – drop buffered bytes
+* `serialAbortRead/Write(...)` – abort pending I/O operations
+
+### Statistics
+* `serialGetRxBytes(handle)` / `serialGetTxBytes(handle)` – cumulative RX / TX byte counters
+
+### Enumeration & autodetect
+* `serialGetPortsInfo(...)` – list available ports under `/dev/serial/by-id`
+
+### Callbacks
+* `serialOnError(func)` – error callback
+* `serialOnRead(func)` – read callback (bytes read)
+* `serialOnWrite(func)` – write callback (bytes written)
+
+Return values ≤ 0 correspond to error codes defined in `status_codes.h`.
+
+---
+
+## 4  Ready-made Deno examples
+
+Two runnable scripts live in `examples/` and require only Deno plus the compiled
+shared library.
+
+- **serial_echo.ts** – Minimal echo test that lists available ports, opens the
+  first one and verifies that the micro-controller echoes the sent string.
+  Run it with:
+  ```bash
+  deno run --allow-ffi --allow-read examples/serial_echo.ts \
+           --lib ./build/libcpp_unix_bindings.so \
+           --port /dev/ttyUSB0
+  ```
+
+- **serial_advanced.ts** – Shows the high-level helpers (`serialWriteLine`,
+  `serialReadLine`, `serialPeek`, `statistics`, `serialDrain`). It sends three
+  lines and then prints the TX/RX counters.
+  ```bash
+  deno run --allow-ffi --allow-read examples/serial_advanced.ts \
+           --lib ./build/libcpp_unix_bindings.so \
+           --port /dev/ttyUSB0
+  ```
+
+Notes:
+1. `--lib` defaults to `./build/libcpp_unix_bindings.so`; pass a custom path if
+you installed the library elsewhere.
+2. `--port` defaults to `/dev/ttyUSB0`; adjust if your board shows up under a
+different device (e.g. `/dev/ttyACM0`).
+3. On most Arduino boards opening the port toggles DTR and triggers a reset.
+   Both scripts therefore wait ~2 s after opening the device before sending the
+   first command.
 
 ---
diff --git a/docs/api_reference.md b/docs/api_reference.md
new file mode 100644
index 0000000..7ef8a2b
--- /dev/null
+++ b/docs/api_reference.md
@@ -0,0 +1,129 @@
+# C API Reference
+
+**Scope** – Public interface of `libcpp_unix_bindings` (C-linkable).  
+*Linux fully supported · Windows fully supported*
+
+Every function is declared in `src/serial.h` and follows the same
+convention: **positive / non-zero** ⇒ success, **≤ 0** ⇒ failure (maps to
+`StatusCodes`).
+
+---
+
+## 1 · Connection
+
+```c
+intptr_t serialOpen(void* port, int baud, int dataBits,
+                    int parity /*0-none·1-even·2-odd*/,
+                    int stopBits /*0-1bit·2-2bit*/);
+
+void serialClose(int64_t handle);
+```
+
+*Linux*: `port` is a NULL-terminated path like `/dev/ttyUSB0` or
+`/dev/tty.SLAB_USBtoUART`.  
+*Windows*: use `"COM3"`, `"\\.\\COM12"`, etc. (to be implemented).
+
+---
+
+## 2 · Basic I/O
+
+```c
+int serialRead (int64_t handle, void* buf, int len, int timeoutMs, int mult);
+int serialWrite(int64_t handle, const void* buf, int len, int timeoutMs, int mult);
+
+int serialReadUntil(int64_t handle, void* buf, int len,
+                    int timeoutMs, int mult, void* untilCharPtr);
+```
+
+*mult* is a polling multiplier (usually **1**). `serialReadUntil` stops **after**
+the delimiter byte has been copied into *buf*.
+
+---
+
+## 3 · Convenience helpers
+
+```c
+int serialReadLine (int64_t h, void* buf, int len, int timeoutMs);          // until '\n'
+int serialWriteLine(int64_t h, const void* buf, int len, int timeoutMs);     // appends '\n'
+
+int serialReadUntilSequence(int64_t h, void* buf, int len,
+                            int timeoutMs, void* sequencePtr);
+
+int serialReadFrame(int64_t h, void* buf, int len, int timeoutMs,
+                    char startByte, char endByte);
+```
+
+---
+
+## 4 · Statistics & Buffer control
+
+```c
+int64_t serialInBytesTotal (int64_t handle);   // cumulative RX
+int64_t serialOutBytesTotal(int64_t handle);   // cumulative TX
+
+int serialInBytesWaiting (int64_t handle);     // queued in driver
+int serialOutBytesWaiting(int64_t handle);
+
+int  serialDrain(int64_t handle);              // wait for TX empty
+
+void serialClearBufferIn (int64_t handle);
+void serialClearBufferOut(int64_t handle);
+
+void serialAbortRead (int64_t handle);
+void serialAbortWrite(int64_t handle);
+```
+
+---
+
+## 5 · Port enumeration & Callbacks
+
+```c
+// Enumerate available ports. For each port the callback receives:
+//   portPath, aliasPath, manufacturer, serialNumber, pnpId,
+//   locationId, productId, vendorId
+int serialGetPortsInfo(void (*cb)(const char*, const char*, const char*,
+                                  const char*, const char*, const char*,
+                                  const char*, const char*));
+
+void serialOnError(void (*cb)(int code, const char* msg));
+void serialOnRead (void (*cb)(int bytes));
+void serialOnWrite(void (*cb)(int bytes));
+```
+
+*Linux*: implementation scans `/dev/serial/by-id` if present, otherwise falls
+back to common tty names.  
+*Windows*: will iterate over available COM ports.
+
+---
+
+## 6 · StatusCodes
+
+```c++
+enum class StatusCodes : int {
+    SUCCESS                 =  0,
+    CLOSE_HANDLE_ERROR      = -1,
+    INVALID_HANDLE_ERROR    = -2,
+    READ_ERROR              = -3,
+    WRITE_ERROR             = -4,
+    GET_STATE_ERROR         = -5,
+    SET_STATE_ERROR         = -6,
+    SET_TIMEOUT_ERROR       = -7,
+    BUFFER_ERROR            = -8,
+    NOT_FOUND_ERROR         = -9,
+    CLEAR_BUFFER_IN_ERROR   = -10,
+    CLEAR_BUFFER_OUT_ERROR  = -11,
+    ABORT_READ_ERROR        = -12,
+    ABORT_WRITE_ERROR       = -13
+};
+```
+
+---
+
+### Error-handling idiom
+
+```c
+int rv = serialWrite(h, data, len, 500, 1);
+if (rv <= 0) {
+    // handle error – detailed info via registered onError callback (if any)
+}
+```
diff --git a/docs/building.md b/docs/building.md
new file mode 100644
index 0000000..fc447a9
--- /dev/null
+++ b/docs/building.md
@@ -0,0 +1,55 @@
+# Building the shared library
+
+## 1. Prerequisites
+
+* **Compiler:** `g++` or `clang++` with C++23 support
+* **CMake ≥ 3.30**
+* POSIX development headers (`termios.h`, `fcntl.h`, …)
+
+Example install on Debian/Ubuntu:
+
+```bash
+sudo apt-get update
+sudo apt-get install build-essential cmake clang make
+```
+
+---
+
+## 2. Configure & Compile
+
+```bash
+# From the repository root
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j$(nproc)
+```
+
+This produces:
+
+* `build/libcpp_unix_bindings.so` – the shared library
+* `build/tests` – aggregated gtest binary (run via `ctest` or `./tests`)
+* `compile_commands.json` – copied to project root for clang-tools
+
+### Debug build
+
+```bash
+cmake -S . -B build/debug -DCMAKE_BUILD_TYPE=Debug
+cmake --build build/debug -j
+```
+
+### Installing system-wide
+
+```bash
+sudo cmake --install build
+```
+
+Set `CMAKE_INSTALL_PREFIX` to control the destination directory.
+
+---
+
+## 3. Troubleshooting
+
+| Symptom | Possible Fix |
+|---------|--------------|
+| *Linker cannot find `stdc++fs`* | Ensure GCC ≥ 8 or Clang ≥ 10 |
+| *Undefined reference to `cfsetspeed`* | Make sure `-pthread` is not stripped |
+| *`EACCES` when opening `/dev/ttyUSB0`* | Add your user to the `dialout` (Ubuntu) or `uucp` (Arch) group or run via `sudo` | 
diff --git a/docs/examples.md b/docs/examples.md
new file mode 100644
index 0000000..6beccb7
--- /dev/null
+++ b/docs/examples.md
@@ -0,0 +1,25 @@
+# Deno example scripts
+
+| Script | Purpose |
+|--------|---------|
+| `serial_echo.ts` | Minimal echo test: enumerate ports, open the first one and verify that each line sent is echoed back by the MCU. |
+| `serial_advanced.ts` | Demonstrates helpers (`serialReadLine`, statistics, peek, `serialDrain`) and prints TX/RX counters. |
+| `serial_callbacks.ts` | Shows how to register error / read / write callbacks and prints diagnostics for every transfer. |
+
+---
+
+## Running an example
+
+```bash
+deno run --allow-ffi --allow-read examples/<script>.ts \
+         --lib ./build/libcpp_unix_bindings.so \
+         --port /dev/ttyUSB0
+```
+
+Flags:
+
+* `--lib` (optional) – path to `libcpp_unix_bindings.so`; defaults to `./build/libcpp_unix_bindings.so`
+* `--port` (optional) – serial device path; defaults to `/dev/ttyUSB0`
+
+If your board resets on opening the port (common on Arduino), scripts wait
+≈2 s before the first write. 
diff --git a/docs/ffi_deno.md b/docs/ffi_deno.md
new file mode 100644
index 0000000..5c704ae
--- /dev/null
+++ b/docs/ffi_deno.md
@@ -0,0 +1,107 @@
+# Using cpp_unix_bindings from Deno
+
+Deno ≥ 1.42 ships a first-class **Foreign-Function Interface (FFI)** that lets
+JavaScript / TypeScript call native C APIs.  This guide explains the few
+patterns you need for smooth interop.
+
+---
+
+## 1. Loading the shared library
+
+```ts
+const dylib = Deno.dlopen(
+  "./build/libcpp_unix_bindings.so",
+  {
+    serialOpen:  { parameters: ["pointer", "i32", "i32", "i32", "i32"], result: "pointer" },
+    serialClose: { parameters: ["pointer"],                result: "void" },
+    // … add further symbols on demand …
+  } as const,
+);
+```
+
+Only the symbols listed in the second argument are made visible to JavaScript.
+Always call `dylib.close()` once you are finished.
+
+---
+
+## 2. Passing strings (null-terminated UTF-8)
+
+```ts
+const encoder = new TextEncoder();
+
+function cString(str: string): Uint8Array {
+  const bytes = encoder.encode(str);
+  const buf = new Uint8Array(bytes.length + 1);
+  buf.set(bytes);
+  buf[bytes.length] = 0; // NUL terminator
+  return buf;
+}
+
+function ptr(view: Uint8Array): Deno.UnsafePointer {
+  return Deno.UnsafePointer.of(view) as Deno.UnsafePointer;
+}
+```
+
+Usage:
+
+```ts
+const handle = dylib.symbols.serialOpen(ptr(cString("/dev/ttyUSB0")), 115200, 8, 0, 0);
+```
+
+---
+
+## 3. Working with buffers
+
+```ts
+const writeBuf = encoder.encode("Hello\n");
+const bytesWritten = dylib.symbols.serialWrite(handle, ptr(writeBuf), writeBuf.length, 100, 1);
+
+const readBuf = new Uint8Array(128);
+const n = dylib.symbols.serialRead(handle, ptr(readBuf), readBuf.length, 500, 1);
+console.log(new TextDecoder().decode(readBuf.subarray(0, n)));
+```
+
+---
+
+## 4. Callbacks
+
+Three optional callbacks can be registered:
+
+* `serialOnError(code: i32, message: *char)`
+* `serialOnRead(bytes: i32)`
+* `serialOnWrite(bytes: i32)`
+
+```ts
+const errorCb = new Deno.UnsafeCallback({
+  parameters: ["i32", "pointer"],
+  result: "void",
+} as const, (code, msgPtr) => {
+  const msg = Deno.UnsafePointerView.getCString(msgPtr);
+  console.error(`[C-API error] (${code}): ${msg}`);
+});
+
+dylib.symbols.serialOnError(errorCb.pointer);
+```
+
+**Remember to `close()` the callback** to avoid leaking the function pointer:
+
+```ts
+errorCb.close();
+```
+
+---
+
+## 5. Cleanup order
+
+```ts
+dylib.symbols.serialClose(handle);
+// Close callbacks first …
+errorCb.close();
+// … then the dynamic library
+
+dylib.close();
+```
+
+---
+
+Refer to the runnable scripts in `examples/` for end-to-end examples. 
diff --git a/docs/overview.md b/docs/overview.md
new file mode 100644
index 0000000..ba140d3
--- /dev/null
+++ b/docs/overview.md
@@ -0,0 +1,23 @@
+# cpp_unix_bindings – Overview
+
+`cpp_unix_bindings` is a compact C++23 shared library that exposes a clean C API for communicating with serial devices on Linux / POSIX.  It is designed to be consumed from high-level runtimes (most notably **Deno**) through a thin FFI layer.
+
+## Key features
+
+* Header-only C API – no C++ ABI headaches
+* Zero external dependencies beyond the standard C library and POSIX (`termios.h`)
+* Robust timeout-aware read / write helpers
+* High-level convenience helpers (`serialReadLine`, framed reads, token reads …)
+* Built-in port enumeration under `/dev/serial/by-id`
+* Optional callbacks for errors, read & write statistics
+* Thread-safe, lock-free I/O abort (`serialAbortRead/Write`)
+* Accurate TX/RX byte counters for live statistics
+
+The repository contains:
+
+* `src/` – core C++ implementation
+* `examples/` – runnable Deno scripts demonstrating usage
+* `tests/` – GoogleTest based C++ unit tests
+* `docs/` – in-depth documentation (this directory)
+
+Supported platforms: **Linux** on x86_64 / ARM.  macOS should compile with minor tweaks but is currently untested. 
diff --git a/examples/serial_advanced.ts b/examples/serial_advanced.ts
new file mode 100644
index 0000000..69f8b9b
--- /dev/null
+++ b/examples/serial_advanced.ts
@@ -0,0 +1,135 @@
+// @ts-nocheck
+// deno run --allow-ffi --allow-read examples/serial_advanced.ts --lib ./build/libcpp_unix_bindings.so --port /dev/ttyUSB0
+
+/*
+   Advanced Deno example showcasing the extended C-API helpers:
+   1. serialReadLine / serialWriteLine for convenient newline-terminated I/O
+   2. serialPeek to inspect next byte without consuming
+   3. Tx/Rx statistics counters
+   4. serialDrain to wait until all bytes are sent
+
+   Build the shared library first (e.g. via `cmake --build build`).
+*/
+
+interface CliOptions {
+    lib: string;
+    port?: string;
+}
+
+function parseArgs(): CliOptions {
+    const opts: CliOptions = { lib: "./build/libcpp_unix_bindings.so" };
+
+    for (let i = 0; i < Deno.args.length; ++i) {
+        const arg = Deno.args[i];
+        if (arg === "--lib" && i + 1 < Deno.args.length) {
+            opts.lib = Deno.args[++i];
+        } else if (arg === "--port" && i + 1 < Deno.args.length) {
+            opts.port = Deno.args[++i];
+        } else {
+            console.warn(`Unknown argument '${arg}' ignored.`);
+        }
+    }
+    return opts;
+}
+
+// -----------------------------------------------------------------------------
+// Helper utilities for C interop
+// -----------------------------------------------------------------------------
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+function cString(str: string): Uint8Array {
+    const bytes = encoder.encode(str);
+    const buf = new Uint8Array(bytes.length + 1);
+    buf.set(bytes, 0);
+    buf[bytes.length] = 0;
+    return buf;
+}
+
+function pointer(view: Uint8Array): Deno.UnsafePointer {
+    return Deno.UnsafePointer.of(view) as Deno.UnsafePointer;
+}
+
+// -----------------------------------------------------------------------------
+// Load dynamic library & bind needed symbols
+// -----------------------------------------------------------------------------
+const { lib, port: cliPort } = parseArgs();
+
+const dylib = Deno.dlopen(
+    lib,
+    {
+        serialOpen: { parameters: ["pointer", "i32", "i32", "i32", "i32"], result: "pointer" },
+        serialClose: { parameters: ["pointer"], result: "void" },
+        serialWriteLine: { parameters: ["pointer", "pointer", "i32", "i32"], result: "i32" },
+        serialReadLine: { parameters: ["pointer", "pointer", "i32", "i32"], result: "i32" },
+        serialPeek: { parameters: ["pointer", "pointer", "i32"], result: "i32" },
+        serialDrain: { parameters: ["pointer"], result: "i32" },
+        serialGetTxBytes: { parameters: ["pointer"], result: "i64" },
+        serialGetRxBytes: { parameters: ["pointer"], result: "i64" },
+    } as const,
+);
+
+// -----------------------------------------------------------------------------
+// Open port
+// -----------------------------------------------------------------------------
+const portPath = cliPort ?? "/dev/ttyUSB0";
+console.log(`Using port: ${portPath}`);
+
+const portBuf = cString(portPath);
+const handle = dylib.symbols.serialOpen(pointer(portBuf), 115200, 8, 0, 0);
+if (handle === null) {
+    console.error("Failed to open port!");
+    dylib.close();
+    Deno.exit(1);
+}
+
+// Wait 2 s for Arduino reset (DTR toggle)
+await new Promise((r) => setTimeout(r, 2000));
+
+// -----------------------------------------------------------------------------
+// 1. Send a few lines and read them back (echo sketch on MCU)
+// -----------------------------------------------------------------------------
+const lines = [
+    "The quick brown fox jumps over the lazy dog",
+    "Grüße aus Deno!",
+    "1234567890",
+];
+
+for (const ln of lines) {
+    const payloadBuf = encoder.encode(ln);
+    const written = dylib.symbols.serialWriteLine(handle, pointer(payloadBuf), payloadBuf.length, 100);
+    if (written !== payloadBuf.length + 1) {
+        console.error(`WriteLine failed for '${ln}'`);
+        continue;
+    }
+
+    // Peek first byte (should be our first char)
+    const peekBuf = new Uint8Array(1);
+    if (dylib.symbols.serialPeek(handle, pointer(peekBuf), 500) === 1) {
+        console.log(`Peek: '${String.fromCharCode(peekBuf[0])}'`);
+    }
+
+    const readBuf = new Uint8Array(256);
+    const n = dylib.symbols.serialReadLine(handle, pointer(readBuf), readBuf.length, 1000);
+    const lineRx = decoder.decode(readBuf.subarray(0, n));
+    console.log(`RX (${n} bytes): '${lineRx}'`);
+}
+
+// Ensure all bytes are transmitted
+if (dylib.symbols.serialDrain(handle) === 1) {
+    console.log("Transmit buffer drained.");
+}
+
+// -----------------------------------------------------------------------------
+// Print statistics
+// -----------------------------------------------------------------------------
+const txBytes = Number(dylib.symbols.serialGetTxBytes(handle));
+const rxBytes = Number(dylib.symbols.serialGetRxBytes(handle));
+console.log(`\nStatistics -> TX: ${txBytes} bytes, RX: ${rxBytes} bytes`);
+
+// -----------------------------------------------------------------------------
+// Cleanup
+// -----------------------------------------------------------------------------
+dylib.symbols.serialClose(handle);
+dylib.close();
+console.log("Done."); 
diff --git a/examples/serial_callbacks.ts b/examples/serial_callbacks.ts
new file mode 100644
index 0000000..54ce246
--- /dev/null
+++ b/examples/serial_callbacks.ts
@@ -0,0 +1,155 @@
+// @ts-nocheck
+// deno run --allow-ffi --allow-read examples/serial_callbacks.ts
+//
+// Demonstrates the optional C-API callbacks (error, read, write).
+// The script registers three callbacks that print diagnostics and then
+// performs a simple line-oriented echo test.
+//
+// CLI flags:
+//   --lib  <path>   Path to the shared library (default ./build/libcpp_unix_bindings.so)
+//   --port <path>   Serial device path     (default /dev/ttyUSB0)
+
+interface CliOptions {
+    lib: string;
+    port?: string;
+}
+
+function parseArgs(): CliOptions {
+    const opts: CliOptions = { lib: "./build/libcpp_unix_bindings.so" };
+
+    for (let i = 0; i < Deno.args.length; ++i) {
+        const arg = Deno.args[i];
+        if (arg === "--lib" && i + 1 < Deno.args.length) {
+            opts.lib = Deno.args[++i];
+        } else if (arg === "--port" && i + 1 < Deno.args.length) {
+            opts.port = Deno.args[++i];
+        } else {
+            console.warn(`Unknown argument '${arg}' ignored.`);
+        }
+    }
+    return opts;
+}
+
+// -----------------------------------------------------------------------------
+// Utilities
+// -----------------------------------------------------------------------------
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+function cString(str: string): Uint8Array {
+    const bytes = encoder.encode(str);
+    const buf = new Uint8Array(bytes.length + 1);
+    buf.set(bytes, 0);
+    buf[bytes.length] = 0;
+    return buf;
+}
+
+function ptr(view: Uint8Array): Deno.UnsafePointer {
+    return Deno.UnsafePointer.of(view) as Deno.UnsafePointer;
+}
+
+// -----------------------------------------------------------------------------
+// Load library & register callbacks
+// -----------------------------------------------------------------------------
+const { lib, port: cliPort } = parseArgs();
+
+const dylib = Deno.dlopen(
+    lib,
+    {
+        serialOpen: { parameters: ["pointer", "i32", "i32", "i32", "i32"], result: "pointer" },
+        serialClose: { parameters: ["pointer"], result: "void" },
+        serialWriteLine: { parameters: ["pointer", "pointer", "i32", "i32"], result: "i32" },
+        serialReadLine: { parameters: ["pointer", "pointer", "i32", "i32"], result: "i32" },
+        serialOnError: { parameters: ["pointer"], result: "void" },
+        serialOnRead: { parameters: ["pointer"], result: "void" },
+        serialOnWrite: { parameters: ["pointer"], result: "void" },
+        serialDrain: { parameters: ["pointer"], result: "i32" },
+    } as const,
+);
+
+const errorCb = new Deno.UnsafeCallback({
+    parameters: ["i32", "pointer"],
+    result: "void",
+} as const, (code, msgPtr) => {
+    const msg = Deno.UnsafePointerView.getCString(msgPtr);
+    console.error(`[C-ERROR] (${code}): ${msg}`);
+});
+
+const readCb = new Deno.UnsafeCallback({
+    parameters: ["i32"],
+    result: "void",
+} as const, (bytes) => {
+    console.log(`[C-READ]  ${bytes} byte(s) received`);
+});
+
+const writeCb = new Deno.UnsafeCallback({
+    parameters: ["i32"],
+    result: "void",
+} as const, (bytes) => {
+    console.log(`[C-WRITE] ${bytes} byte(s) transmitted`);
+});
+
+dylib.symbols.serialOnError(errorCb.pointer);
+dylib.symbols.serialOnRead(readCb.pointer);
+dylib.symbols.serialOnWrite(writeCb.pointer);
+
+// -----------------------------------------------------------------------------
+// Open port
+// -----------------------------------------------------------------------------
+const portPath = cliPort ?? "/dev/ttyUSB0";
+console.log(`Opening port: ${portPath}`);
+
+let handle: Deno.PointerValue | null = dylib.symbols.serialOpen(ptr(cString(portPath)), 115200, 8, 0, 0);
+if (handle === null) {
+    console.error("Failed to open port.");
+    cleanup();
+    Deno.exit(1);
+}
+
+// Give MCU time to reset (common on Arduino)
+await new Promise((r) => setTimeout(r, 2000));
+
+// -----------------------------------------------------------------------------
+// Echo interaction
+// -----------------------------------------------------------------------------
+const message = `Callback test ${Date.now()}`;
+const msgBuf = encoder.encode(message);
+
+console.log(`Sending: '${message}'`);
+const written = dylib.symbols.serialWriteLine(handle, ptr(msgBuf), msgBuf.length, 100);
+if (written !== msgBuf.length + 1) {
+    console.error("serialWriteLine wrote unexpected byte count");
+}
+
+const rxBuf = new Uint8Array(256);
+const n = dylib.symbols.serialReadLine(handle, ptr(rxBuf), rxBuf.length, 1000);
+const response = decoder.decode(rxBuf.subarray(0, n));
+
+console.log(`Received (${n} bytes): '${response}'`);
+
+if (response === message) {
+    console.log("Echo OK ✅");
+} else {
+    console.warn("Echo mismatch ⚠");
+}
+
+// Wait until TX queue is empty then close
+if (dylib.symbols.serialDrain(handle) === 1) {
+    console.log("Transmit buffer drained.");
+}
+
+cleanup();
+
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+function cleanup() {
+    if (handle !== null) {
+        dylib.symbols.serialClose(handle);
+        handle = null;
+    }
+    errorCb.close();
+    readCb.close();
+    writeCb.close();
+    dylib.close();
+} 
diff --git a/examples/serial_echo.ts b/examples/serial_echo.ts
index 91c6fcd..e58edca 100644
--- a/examples/serial_echo.ts
+++ b/examples/serial_echo.ts
@@ -7,7 +7,7 @@ interface CliOptions {
 }
 
 function parseArgs(): CliOptions {
-    const opts: CliOptions = { lib: "./build/libCPP-Unix-Bindings.so" };
+    const opts: CliOptions = { lib: "./build/libcpp_unix_bindings.so" };
 
     for (let i = 0; i < Deno.args.length; ++i) {
         const arg = Deno.args[i];
@@ -56,43 +56,100 @@ const dylib = Deno.dlopen(
             parameters: ["pointer", "pointer", "i32", "i32", "i32", "pointer"],
             result: "i32",
         },
-        serialGetPortsInfo: { parameters: ["pointer", "i32", "pointer"], result: "i32" },
+        serialGetPortsInfo: { parameters: ["function"], result: "i32" },
     } as const,
 );
 
 // -----------------------------------------------------------------------------
-// 1. List available ports
+// 1. List available ports with extended info
 // -----------------------------------------------------------------------------
-const sepBuf = cString(";");
-const portsBuf = new Uint8Array(4096);
-dylib.symbols.serialGetPortsInfo(
-    pointer(portsBuf),
-    portsBuf.length,
-    pointer(sepBuf),
-);
 
-const cPortsStr = decoder.decode(portsBuf.subarray(0, portsBuf.indexOf(0)));
-const ports = cPortsStr ? cPortsStr.split(";") : [];
-console.log("Available ports:");
-for (const p of ports) {
-    console.log(" •", p);
+// Storage for callback results
+interface PortInfo {
+    port: string;
+    path: string;
+    manufacturer: string;
+    serial: string;
+    pnpId: string;
+    locationId: string;
+    productId: string;
+    vendorId: string;
+}
+
+const portsInfo: PortInfo[] = [];
+
+// Helper to read C string from pointer
+function cstr(ptr: Deno.PointerValue): string {
+    if (ptr === 0n) return "";
+    return Deno.UnsafePointerView.getCString(ptr);
 }
-if (ports.length === 0) {
-    console.error("No serial ports found (ttyUSB). Exiting.");
+
+const portInfoCallback = new Deno.UnsafeCallback({
+    parameters: [
+        "pointer", // port
+        "pointer", // path
+        "pointer", // manufacturer
+        "pointer", // serialNumber
+        "pointer", // pnpId
+        "pointer", // locationId
+        "pointer", // productId
+        "pointer", // vendorId
+    ],
+    result: "void",
+} as const, (
+    portPtr,
+    pathPtr,
+    manufacturerPtr,
+    serialPtr,
+    pnpPtr,
+    locationPtr,
+    productPtr,
+    vendorPtr,
+) => {
+    portsInfo.push({
+        port: cstr(portPtr),
+        path: cstr(pathPtr),
+        manufacturer: cstr(manufacturerPtr),
+        serial: cstr(serialPtr),
+        pnpId: cstr(pnpPtr),
+        locationId: cstr(locationPtr),
+        productId: cstr(productPtr),
+        vendorId: cstr(vendorPtr),
+    });
+});
+
+const numPorts = dylib.symbols.serialGetPortsInfo(portInfoCallback.pointer);
+
+if (numPorts === 0) {
+    console.error("No serial ports found. Exiting.");
+    portInfoCallback.close();
     dylib.close();
     Deno.exit(1);
 }
 
+console.log("Available ports:");
+for (const p of portsInfo) {
+    console.log(` • ${p.port}`);
+    console.log(`     alias        : ${p.path}`);
+    if (p.manufacturer) console.log(`     manufacturer : ${p.manufacturer}`);
+    if (p.serial) console.log(`     serial       : ${p.serial}`);
+    if (p.vendorId) console.log(`     vendorId     : ${p.vendorId}`);
+    if (p.productId) console.log(`     productId    : ${p.productId}`);
+    if (p.pnpId) console.log(`     pnpId        : ${p.pnpId}`);
+    if (p.locationId) console.log(`     locationId   : ${p.locationId}`);
+}
+
 // -----------------------------------------------------------------------------
 // 2. Echo test on selected port
 // -----------------------------------------------------------------------------
-const portPath = cliPort ?? ports[0];
+const portPath = cliPort ?? portsInfo[0].port;
 console.log(`\nUsing port: ${portPath}`);
 
 const portBuf = cString(portPath);
 const handle = dylib.symbols.serialOpen(pointer(portBuf), 115200, 8, 0, 0);
 if (handle === null) {
     console.error("Failed to open port!");
+    portInfoCallback.close();
     dylib.close();
     Deno.exit(1);
 }
@@ -106,6 +163,7 @@ const written = dylib.symbols.serialWrite(handle, pointer(msgBuf), msgBuf.length
 if (written !== msgBuf.length) {
     console.error(`Write failed (wrote ${written}/${msgBuf.length})`);
     dylib.symbols.serialClose(handle);
+    portInfoCallback.close();
     dylib.close();
     Deno.exit(1);
 }
@@ -117,6 +175,7 @@ const read = dylib.symbols.serialReadUntil(handle, pointer(readBuf), readBuf.len
 if (read <= 0) {
     console.error("Read failed or timed out.");
     dylib.symbols.serialClose(handle);
+    portInfoCallback.close();
     dylib.close();
     Deno.exit(1);
 }
@@ -131,4 +190,5 @@ if (echo === msg) {
 }
 
 dylib.symbols.serialClose(handle);
+portInfoCallback.close();
 dylib.close(); 
diff --git a/src/serial.cpp b/src/serial.cpp
deleted file mode 100644
index 82aec05..0000000
--- a/src/serial.cpp
+++ /dev/null
@@ -1,402 +0,0 @@
-#include "serial.h"
-
-#include "status_codes.h"
-
-#include <algorithm>
-#include <cstring>
-#include <fcntl.h>
-#include <filesystem>
-#include <string>
-#include <string_view>
-#include <sys/ioctl.h>
-#include <sys/select.h>
-#include <termios.h>
-#include <unistd.h>
-#include <utility>
-
-// -----------------------------------------------------------------------------
-// Global callback function pointers (default nullptr)
-// -----------------------------------------------------------------------------
-void (*error_callback)(int) = nullptr;
-void (*read_callback)(int) = nullptr;
-void (*write_callback)(int) = nullptr;
-
-// -----------------------------------------------------------------------------
-// Internal helpers & types
-// -----------------------------------------------------------------------------
-namespace
-{
-
-struct SerialPortHandle
-{
-    int fd;
-    termios original; // keep original settings so we can restore on close
-};
-
-// Map integer baudrate to POSIX speed_t. Only common rates are supported.
-auto to_speed_t(int baud) -> speed_t
-{
-    switch (baud)
-    {
-    case 0:
-        return B0;
-    case 50:
-        return B50;
-    case 75:
-        return B75;
-    case 110:
-        return B110;
-    case 134:
-        return B134;
-    case 150:
-        return B150;
-    case 200:
-        return B200;
-    case 300:
-        return B300;
-    case 600:
-        return B600;
-    case 1200:
-        return B1200;
-    case 1800:
-        return B1800;
-    case 2400:
-        return B2400;
-    case 4800:
-        return B4800;
-    case 9600:
-        return B9600;
-    case 19200:
-        return B19200;
-    case 38400:
-        return B38400;
-    case 57600:
-        return B57600;
-    case 115200:
-        return B115200;
-    case 230400:
-        return B230400;
-#ifdef B460800
-    case 460800:
-        return B460800;
-#endif
-#ifdef B921600
-    case 921600:
-        return B921600;
-#endif
-    default:
-        return B9600; // fallback
-    }
-}
-
-inline void invokeError(int code)
-{
-    if (error_callback != nullptr)
-    {
-        error_callback(code);
-    }
-}
-
-} // namespace
-
-// -----------------------------------------------------------------------------
-// Public API implementation
-// -----------------------------------------------------------------------------
-
-intptr_t serialOpen(void* port, int baudrate, int dataBits, int parity, int stopBits)
-{
-    if (port == nullptr)
-    {
-        invokeError(std::to_underlying(StatusCodes::INVALID_HANDLE_ERROR));
-        return 0;
-    }
-
-    auto port_name = std::string_view{static_cast<const char*>(port)};
-    int fd = open(port_name.data(), O_RDWR | O_NOCTTY | O_SYNC);
-    if (fd < 0)
-    {
-        invokeError(std::to_underlying(StatusCodes::INVALID_HANDLE_ERROR));
-        return 0;
-    }
-
-    auto* handle = new SerialPortHandle{.fd = fd, .original = {}};
-
-    termios tty{};
-    if (tcgetattr(fd, &tty) != 0)
-    {
-        invokeError(std::to_underlying(StatusCodes::GET_STATE_ERROR));
-        close(fd);
-        delete handle;
-        return 0;
-    }
-    handle->original = tty; // save original
-
-    // Basic flags: local connection, enable receiver
-    tty.c_cflag |= (CLOCAL | CREAD);
-
-    // Baudrate
-    const speed_t speed = to_speed_t(baudrate);
-    cfsetispeed(&tty, speed);
-    cfsetospeed(&tty, speed);
-
-    // Data bits
-    tty.c_cflag &= ~CSIZE;
-    switch (dataBits)
-    {
-    case 5:
-        tty.c_cflag |= CS5;
-        break;
-    case 6:
-        tty.c_cflag |= CS6;
-        break;
-    case 7:
-        tty.c_cflag |= CS7;
-        break;
-    default:
-        tty.c_cflag |= CS8;
-        break;
-    }
-
-    // Parity
-    if (parity == 0)
-    {
-        tty.c_cflag &= ~PARENB;
-    }
-    else
-    {
-        tty.c_cflag |= PARENB;
-        if (parity == 1)
-        {
-            tty.c_cflag &= ~PARODD; // even
-        }
-        else
-        {
-            tty.c_cflag |= PARODD; // odd
-        }
-    }
-
-    // Stop bits
-    if (stopBits == 2)
-    {
-        tty.c_cflag |= CSTOPB;
-    }
-    else
-    {
-        tty.c_cflag &= ~CSTOPB;
-    }
-
-    // Raw mode (no echo/processing)
-    tty.c_iflag = 0;
-    tty.c_oflag = 0;
-    tty.c_lflag = 0;
-
-    tty.c_cc[VMIN] = 0;   // non-blocking by default
-    tty.c_cc[VTIME] = 10; // 1s read timeout
-
-    if (tcsetattr(fd, TCSANOW, &tty) != 0)
-    {
-        invokeError(std::to_underlying(StatusCodes::SET_STATE_ERROR));
-        close(fd);
-        delete handle;
-        return 0;
-    }
-
-    return reinterpret_cast<intptr_t>(handle);
-}
-
-void serialClose(int64_t handlePtr)
-{
-    auto* handle = reinterpret_cast<SerialPortHandle*>(handlePtr);
-    if (handle == nullptr)
-    {
-        return;
-    }
-
-    tcsetattr(handle->fd, TCSANOW, &handle->original); // restore
-    if (close(handle->fd) != 0)
-    {
-        invokeError(std::to_underlying(StatusCodes::CLOSE_HANDLE_ERROR));
-    }
-    delete handle;
-}
-
-static int waitFdReady(int fd, int timeoutMs, bool wantWrite)
-{
-    timeoutMs = std::max(timeoutMs, 0);
-
-    fd_set set;
-    FD_ZERO(&set);
-    FD_SET(fd, &set);
-
-    timeval tv{};
-    tv.tv_sec = timeoutMs / 1000;
-    tv.tv_usec = (timeoutMs % 1000) * 1000;
-
-    int res = select(fd + 1, wantWrite ? nullptr : &set, wantWrite ? &set : nullptr, nullptr, &tv);
-    return res; // 0 timeout, -1 error, >0 ready
-}
-
-int serialRead(int64_t handlePtr, void* buffer, int bufferSize, int timeout, int /*multiplier*/)
-{
-    auto* handle = reinterpret_cast<SerialPortHandle*>(handlePtr);
-    if (handle == nullptr)
-    {
-        invokeError(std::to_underlying(StatusCodes::INVALID_HANDLE_ERROR));
-        return 0;
-    }
-
-    if (waitFdReady(handle->fd, timeout, false) <= 0)
-    {
-        return 0; // timeout or error (we ignore error for now)
-    }
-
-    ssize_t n = read(handle->fd, buffer, bufferSize);
-    if (n < 0)
-    {
-        invokeError(std::to_underlying(StatusCodes::READ_ERROR));
-        return 0;
-    }
-    if (read_callback != nullptr)
-    {
-        read_callback(static_cast<int>(n));
-    }
-    return static_cast<int>(n);
-}
-
-int serialWrite(int64_t handlePtr, const void* buffer, int bufferSize, int timeout, int /*multiplier*/)
-{
-    auto* handle = reinterpret_cast<SerialPortHandle*>(handlePtr);
-    if (handle == nullptr)
-    {
-        invokeError(std::to_underlying(StatusCodes::INVALID_HANDLE_ERROR));
-        return 0;
-    }
-
-    if (waitFdReady(handle->fd, timeout, true) <= 0)
-    {
-        return 0; // timeout or error
-    }
-
-    ssize_t n = write(handle->fd, buffer, bufferSize);
-    if (n < 0)
-    {
-        invokeError(std::to_underlying(StatusCodes::WRITE_ERROR));
-        return 0;
-    }
-    if (write_callback != nullptr)
-    {
-        write_callback(static_cast<int>(n));
-    }
-    return static_cast<int>(n);
-}
-
-int serialReadUntil(int64_t handlePtr, void* buffer, int bufferSize, int timeout, int /*multiplier*/, void* untilCharPtr)
-{
-    auto* handle = reinterpret_cast<SerialPortHandle*>(handlePtr);
-    if (handle == nullptr)
-    {
-        invokeError(std::to_underlying(StatusCodes::INVALID_HANDLE_ERROR));
-        return 0;
-    }
-
-    char until_char = *static_cast<char*>(untilCharPtr);
-    int total = 0;
-    auto* buf = static_cast<char*>(buffer);
-
-    while (total < bufferSize)
-    {
-        int res = serialRead(handlePtr, buf + total, 1, timeout, 1);
-        if (res <= 0)
-        {
-            break; // timeout or error
-        }
-        if (buf[total] == until_char)
-        {
-            total += 1;
-            break;
-        }
-        total += res;
-    }
-
-    if (read_callback != nullptr)
-    {
-        read_callback(total);
-    }
-    return total;
-}
-
-int serialGetPortsInfo(void* buffer, int bufferSize, void* separatorPtr)
-{
-    auto sep = std::string_view{static_cast<const char*>(separatorPtr)};
-    std::string result;
-
-    namespace fs = std::filesystem;
-
-    const fs::path by_id_dir{"/dev/serial/by-id"};
-    if (!fs::exists(by_id_dir) || !fs::is_directory(by_id_dir))
-    {
-        invokeError(std::to_underlying(StatusCodes::NOT_FOUND_ERROR));
-        return 0;
-    }
-
-    try
-    {
-        for (const auto& entry : fs::directory_iterator{by_id_dir})
-        {
-            if (!entry.is_symlink())
-            {
-                continue;
-            }
-
-            std::error_code ec;
-            fs::path canonical = fs::canonical(entry.path(), ec);
-            if (ec)
-            {
-                continue; // skip entries we cannot resolve
-            }
-
-            result += canonical.string();
-            result += sep;
-        }
-    }
-    catch (const fs::filesystem_error&)
-    {
-        invokeError(std::to_underlying(StatusCodes::NOT_FOUND_ERROR));
-        return 0;
-    }
-
-    if (!result.empty())
-    {
-        // Remove the trailing separator
-        result.erase(result.size() - sep.size());
-    }
-
-    if (static_cast<int>(result.size()) + 1 > bufferSize)
-    {
-        invokeError(std::to_underlying(StatusCodes::BUFFER_ERROR));
-        return 0;
-    }
-
-    std::memcpy(buffer, result.c_str(), result.size() + 1);
-    return result.empty() ? 0 : 1; // number of ports not easily counted here
-}
-
-// Currently stubbed helpers (no-ops)
-void serialClearBufferIn(int64_t /*unused*/) {}
-void serialClearBufferOut(int64_t /*unused*/) {}
-void serialAbortRead(int64_t /*unused*/) {}
-void serialAbortWrite(int64_t /*unused*/) {}
-
-// Callback registration
-void serialOnError(void (*func)(int code))
-{
-    error_callback = func;
-}
-void serialOnRead(void (*func)(int bytes))
-{
-    read_callback = func;
-}
-void serialOnWrite(void (*func)(int bytes))
-{
-    write_callback = func;
-}
diff --git a/src/serial.h b/src/serial.h
deleted file mode 100644
index 73a2c4e..0000000
--- a/src/serial.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-#include <cstdint>
-
-#define MODULE_API __attribute__((visibility("default")))
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    // Version helpers generated at configure time
-    MODULE_API unsigned int getMajorVersion();
-    MODULE_API unsigned int getMinorVersion();
-    MODULE_API unsigned int getPatchVersion();
-
-    // Basic serial API
-    MODULE_API intptr_t
-    serialOpen(void* port, int baudrate, int dataBits, int parity /*0-none,1-even,2-odd*/ = 0, int stopBits /*0-1bit,2-2bit*/ = 0);
-
-    MODULE_API void serialClose(int64_t handle);
-
-    MODULE_API int serialRead(int64_t handle, void* buffer, int bufferSize, int timeout /*ms*/, int multiplier);
-
-    MODULE_API int serialReadUntil(int64_t handle, void* buffer, int bufferSize, int timeout, int multiplier, void* untilChar);
-
-    MODULE_API int serialWrite(int64_t handle, const void* buffer, int bufferSize, int timeout, int multiplier);
-
-    MODULE_API int serialGetPortsInfo(void* buffer, int bufferSize, void* separator);
-
-    MODULE_API void serialClearBufferIn(int64_t handle);
-    MODULE_API void serialClearBufferOut(int64_t handle);
-    MODULE_API void serialAbortRead(int64_t handle);
-    MODULE_API void serialAbortWrite(int64_t handle);
-
-    // Optional callback hooks (can be nullptr)
-    extern void (*error_callback)(int errorCode);
-    extern void (*read_callback)(int bytes);
-    extern void (*write_callback)(int bytes);
-
-    MODULE_API void serialOnError(void (*func)(int code));
-    MODULE_API void serialOnRead(void (*func)(int bytes));
-    MODULE_API void serialOnWrite(void (*func)(int bytes));
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/src/serial_abort_read.cpp b/src/serial_abort_read.cpp
new file mode 100644
index 0000000..cbe881f
--- /dev/null
+++ b/src/serial_abort_read.cpp
@@ -0,0 +1,26 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_abort_read.h>
+#include <cstdint>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialAbortRead(int64_t handle_ptr, ErrorCallbackT error_callback) -> int
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialAbortRead: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    handle->abort_read = true;
+    return 0;
+}
diff --git a/src/serial_abort_write.cpp b/src/serial_abort_write.cpp
new file mode 100644
index 0000000..f9ba56e
--- /dev/null
+++ b/src/serial_abort_write.cpp
@@ -0,0 +1,26 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_abort_write.h>
+#include <cstdint>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialAbortWrite(int64_t handle_ptr, ErrorCallbackT error_callback) -> int
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialAbortWrite: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    handle->abort_write = true;
+    return 0;
+}
diff --git a/src/serial_clear_buffer_in.cpp b/src/serial_clear_buffer_in.cpp
new file mode 100644
index 0000000..0566651
--- /dev/null
+++ b/src/serial_clear_buffer_in.cpp
@@ -0,0 +1,38 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_clear_buffer_in.h>
+#include <cstdint>
+#include <mutex>
+#include <termios.h>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialClearBufferIn(int64_t handle_ptr, ErrorCallbackT error_callback) -> int
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialClearBufferIn: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+
+    if (tcflush(handle->fd, TCIFLUSH) != 0)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kClearBufferInError),
+            "serialClearBufferIn: Failed to flush input buffer",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kClearBufferInError);
+    }
+    return 0;
+}
diff --git a/src/serial_clear_buffer_out.cpp b/src/serial_clear_buffer_out.cpp
new file mode 100644
index 0000000..77664ec
--- /dev/null
+++ b/src/serial_clear_buffer_out.cpp
@@ -0,0 +1,42 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_clear_buffer_out.h>
+#include <cstdint>
+#include <mutex>
+#include <termios.h>
+#include <utility>
+
+using serial_internal::invokeError;
+using serial_internal::SerialPortHandle;
+
+extern "C" auto serialClearBufferOut(
+    int64_t        handle_ptr,
+    ErrorCallbackT error_callback
+) -> int
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialClearBufferOut: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+
+    if (tcflush(handle->fd, TCOFLUSH) != 0)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kClearBufferOutError),
+            "serialClearBufferOut: Failed to flush output buffer",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kClearBufferOutError);
+    }
+    return 0;
+}
diff --git a/src/serial_close.cpp b/src/serial_close.cpp
new file mode 100644
index 0000000..adc61ce
--- /dev/null
+++ b/src/serial_close.cpp
@@ -0,0 +1,49 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_close.h>
+#include <cstdint>
+#include <mutex>
+#include <termios.h>
+#include <unistd.h>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialClose(int64_t handle_ptr, ErrorCallbackT error_callback) -> int
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        // Nothing to do – spec says it is a no-op, but we still report success.
+        return 0;
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+
+    // Restore original settings and close the descriptor.
+    if (tcsetattr(handle->fd, TCSANOW, &handle->original) != 0)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kSetStateError),
+            "serialClose: Failed to restore attributes",
+            error_callback
+        );
+        // Continue with close anyway.
+    }
+
+    if (close(handle->fd) != 0)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kCloseHandleError),
+            "serialClose: Failed to close port",
+            error_callback
+        );
+        delete handle;
+        return std::to_underlying(cpp_core::StatusCodes::kCloseHandleError);
+    }
+
+    delete handle;
+    return 0;
+}
diff --git a/src/serial_drain.cpp b/src/serial_drain.cpp
new file mode 100644
index 0000000..86c2a66
--- /dev/null
+++ b/src/serial_drain.cpp
@@ -0,0 +1,36 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_drain.h>
+#include <cstdint>
+#include <mutex>
+#include <termios.h>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialDrain(int64_t handle_ptr, ErrorCallbackT error_callback) -> int
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialDrain: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+
+    if (tcdrain(handle->fd) != 0)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kGetStateError), "serialDrain: tcdrain failed", error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kGetStateError);
+    }
+    return 0;
+}
diff --git a/src/serial_in_bytes_total.cpp b/src/serial_in_bytes_total.cpp
new file mode 100644
index 0000000..ff27a8e
--- /dev/null
+++ b/src/serial_in_bytes_total.cpp
@@ -0,0 +1,21 @@
+#include "cpp_core/error_callback.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_in_bytes_total.h>
+#include <cstdint>
+#include <mutex>
+
+using namespace serial_internal;
+
+extern "C" auto serialInBytesTotal(int64_t handle_ptr, ErrorCallbackT /*error_callback*/
+                                   ) -> int64_t
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        return 0;
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+    return handle->rx_total;
+}
diff --git a/src/serial_in_bytes_waiting.cpp b/src/serial_in_bytes_waiting.cpp
new file mode 100644
index 0000000..5ee258c
--- /dev/null
+++ b/src/serial_in_bytes_waiting.cpp
@@ -0,0 +1,40 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <asm-generic/ioctls.h>
+#include <cpp_core/interface/serial_in_bytes_waiting.h>
+#include <cstdint>
+#include <mutex>
+#include <sys/ioctl.h>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialInBytesWaiting(int64_t handle_ptr, ErrorCallbackT error_callback) -> int
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialInBytesWaiting: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+
+    int available = 0;
+    if (ioctl(handle->fd, FIONREAD, &available) == -1)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kGetStateError),
+            "serialInBytesWaiting: ioctl failed",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kGetStateError);
+    }
+    return available;
+}
diff --git a/src/serial_internal.hpp b/src/serial_internal.hpp
new file mode 100644
index 0000000..e4df2bf
--- /dev/null
+++ b/src/serial_internal.hpp
@@ -0,0 +1,133 @@
+#pragma once
+
+#include <algorithm>
+#include <atomic>
+#include <cpp_core/error_callback.h>
+#include <cpp_core/status_codes.h>
+#include <cstdint>
+#include <fcntl.h>
+#include <mutex>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <termios.h>
+#include <unistd.h>
+#include <utility>
+
+namespace serial_internal
+{
+// ----------------------------------------------------------------------------
+// Global callback function pointers (registered via serialSet*Callback APIs)
+// ----------------------------------------------------------------------------
+extern ErrorCallbackT g_error_callback;
+extern void (*g_read_callback)(int);
+extern void (*g_write_callback)(int);
+
+// ----------------------------------------------------------------------------
+// Helper to invoke the correct error callback (per-call overrides global)
+// ----------------------------------------------------------------------------
+inline void invokeError(int code, const char* message, ErrorCallbackT local)
+{
+    if (local != nullptr)
+    {
+        local(code, message);
+    }
+    else if (g_error_callback != nullptr)
+    {
+        g_error_callback(code, message);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Serial port handle that is returned to the user (opaque).
+// ----------------------------------------------------------------------------
+struct SerialPortHandle
+{
+    int fd{-1};         // File descriptor (POSIX)
+    termios original{}; // Original TTY settings, restored on close.
+
+    int64_t rx_total{0};
+    int64_t tx_total{0};
+
+    std::recursive_mutex mtx; // Protects concurrent read/write operations
+    std::atomic<bool> abort_read{false};
+    std::atomic<bool> abort_write{false};
+};
+
+// ----------------------------------------------------------------------------
+// Utility: map integer baud rate to POSIX speed_t.
+// ----------------------------------------------------------------------------
+inline speed_t to_speed_t(int baud)
+{
+    switch (baud)
+    {
+    case 0:
+        return B0;
+    case 50:
+        return B50;
+    case 75:
+        return B75;
+    case 110:
+        return B110;
+    case 134:
+        return B134;
+    case 150:
+        return B150;
+    case 200:
+        return B200;
+    case 300:
+        return B300;
+    case 600:
+        return B600;
+    case 1200:
+        return B1200;
+    case 1800:
+        return B1800;
+    case 2400:
+        return B2400;
+    case 4800:
+        return B4800;
+    case 9600:
+        return B9600;
+    case 19200:
+        return B19200;
+    case 38400:
+        return B38400;
+    case 57600:
+        return B57600;
+    case 115200:
+        return B115200;
+    case 230400:
+        return B230400;
+#ifdef B460800
+    case 460800:
+        return B460800;
+#endif
+#ifdef B921600
+    case 921600:
+        return B921600;
+#endif
+    default:
+        return B9600; // reasonable fallback
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Wait until the file descriptor is ready for read/write (select based).
+// Returns >0 on ready, 0 on timeout, -1 on error.
+// ----------------------------------------------------------------------------
+inline int waitFdReady(int fd, int timeout_ms, bool want_write)
+{
+    timeout_ms = std::max(timeout_ms, 0);
+
+    fd_set set;
+    FD_ZERO(&set);
+    FD_SET(fd, &set);
+
+    timeval tv{};
+    tv.tv_sec = timeout_ms / 1000;
+    tv.tv_usec = (timeout_ms % 1000) * 1000;
+
+    return select(fd + 1, want_write ? nullptr : &set, want_write ? &set : nullptr, nullptr, &tv);
+}
+
+} // namespace serial_internal
diff --git a/src/serial_list_ports.cpp b/src/serial_list_ports.cpp
new file mode 100644
index 0000000..7ec9f53
--- /dev/null
+++ b/src/serial_list_ports.cpp
@@ -0,0 +1,172 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_list_ports.h>
+#include <filesystem>
+#include <fstream>
+#include <string>
+#include <system_error>
+#include <utility>
+
+namespace
+{
+namespace fs = std::filesystem;
+
+using serial_internal::g_error_callback;
+using serial_internal::invokeError;
+
+// Reads a single attribute file from a given directory. Returns empty string on error.
+auto readAttr(const fs::path &dir, const std::string &attr) -> std::string
+{
+    std::ifstream file(dir / attr);
+    if (!file.is_open())
+    {
+        return "";
+    }
+    std::string value;
+    std::getline(file, value);
+    return value;
+}
+
+struct UsbInfo
+{
+    std::string manufacturer;
+    std::string serial_number;
+    std::string vendor_id;
+    std::string product_id;
+    std::string pnp_id;
+    std::string location_id;
+};
+
+// Attempts to locate the USB device directory for a tty canonical path and collect attributes.
+auto collectUsbInfo(const fs::path &canonical_path) -> UsbInfo
+{
+    UsbInfo info{};
+
+    std::error_code error_code;
+    fs::path tty_sys = fs::path{"/sys/class/tty"} / canonical_path.filename() / "device";
+    tty_sys                 = fs::canonical(tty_sys, error_code);
+    if (error_code)
+    {
+        return info; // return empty info if we cannot resolve
+    }
+
+    fs::path usb_dir;
+    fs::path cur = tty_sys;
+    while (cur.has_relative_path() && cur != cur.root_path())
+    {
+        if (fs::exists(cur / "idVendor"))
+        {
+            usb_dir = cur;
+            break;
+        }
+        cur = cur.parent_path();
+    }
+
+    if (usb_dir.empty())
+    {
+        return info; // not a USB device (e.g., built-in tty)
+    }
+
+    info.manufacturer  = readAttr(usb_dir, "manufacturer");
+    info.serial_number = readAttr(usb_dir, "serial");
+    info.vendor_id     = readAttr(usb_dir, "idVendor");
+    info.product_id    = readAttr(usb_dir, "idProduct");
+
+    if (!info.vendor_id.empty() && !info.product_id.empty())
+    {
+        info.pnp_id = "USB\\VID_" + info.vendor_id + "&PID_" + info.product_id;
+    }
+
+    const std::string busnum  = readAttr(usb_dir, "busnum");
+    const std::string devpath = readAttr(usb_dir, "devpath");
+    if (!busnum.empty() && !devpath.empty())
+    {
+        info.location_id = busnum + ":" + devpath;
+    }
+
+    return info;
+}
+
+// Handles a single directory entry. Returns true if a port was reported.
+auto handleEntry(const fs::directory_entry &entry,
+                 void (*callback)(const char *, const char *, const char *, const char *, const char *, const char *,
+                                  const char *, const char *)) -> bool
+{
+    if (!entry.is_symlink())
+    {
+        return false;
+    }
+
+    std::error_code error_code;
+    fs::path const canonical = fs::canonical(entry.path(), error_code);
+    if (error_code)
+    {
+        return false;
+    }
+
+    const std::string port_path    = canonical.string();
+    const std::string symlink_path = entry.path().string();
+
+    UsbInfo const info = collectUsbInfo(canonical);
+
+    if (callback != nullptr)
+    {
+        callback(
+            port_path.c_str(),
+            symlink_path.c_str(),
+            info.manufacturer.c_str(),
+            info.serial_number.c_str(),
+            info.pnp_id.c_str(),
+            info.location_id.c_str(),
+            info.product_id.c_str(),
+            info.vendor_id.c_str()
+        );
+    }
+    return true;
+}
+
+} // namespace
+
+extern "C" auto serialListPorts(void (*callback_fn)(const char *port, const char *path, const char *manufacturer,
+                                                    const char *serial_number, const char *pnp_id,
+                                                    const char *location_id, const char *product_id,
+                                                    const char *vendor_id),
+                                ErrorCallbackT error_callback) -> int
+{
+    const fs::path by_id_dir{"/dev/serial/by-id"};
+    if (!fs::exists(by_id_dir) || !fs::is_directory(by_id_dir))
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kNotFoundError),
+            "serialListPorts: Failed to get ports info",
+            error_callback
+        );
+        return 0;
+    }
+
+    int count = 0;
+
+    try
+    {
+        for (const auto &entry : fs::directory_iterator{by_id_dir})
+        {
+            if (handleEntry(entry, callback_fn))
+            {
+                ++count;
+            }
+        }
+    }
+    catch (const fs::filesystem_error &)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kNotFoundError),
+            "serialListPorts: Failed to get ports info",
+            error_callback
+        );
+        return 0;
+    }
+
+    return count;
+}
diff --git a/src/serial_open.cpp b/src/serial_open.cpp
new file mode 100644
index 0000000..d312170
--- /dev/null
+++ b/src/serial_open.cpp
@@ -0,0 +1,133 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_open.h>
+#include <cstdint>
+#include <fcntl.h>
+#include <string_view>
+#include <termios.h>
+#include <unistd.h>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialOpen(void *port, int baudrate, int data_bits, int parity, int stop_bits,
+                           ErrorCallbackT error_callback) -> intptr_t
+{
+    if (port == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialOpen: Invalid port handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    std::string_view const port_name{static_cast<const char *>(port)};
+    int const fd = open(port_name.data(), O_RDWR | O_NOCTTY | O_SYNC);
+    if (fd < 0)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialOpen: Failed to open serial port",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    auto *handle = new SerialPortHandle{};
+    handle->fd   = fd;
+
+    termios tty{};
+    if (tcgetattr(fd, &tty) != 0)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kGetStateError),
+            "serialOpen: Failed to get port attributes",
+            error_callback
+        );
+        close(fd);
+        delete handle;
+        return std::to_underlying(cpp_core::StatusCodes::kGetStateError);
+    }
+
+    handle->original = tty; // Save original settings
+
+    // Local connection, enable receiver
+    tty.c_cflag |= (CLOCAL | CREAD);
+
+    // Baud rate
+    const speed_t speed = to_speed_t(baudrate);
+    cfsetispeed(&tty, speed);
+    cfsetospeed(&tty, speed);
+
+    // Data bits
+    tty.c_cflag &= ~CSIZE;
+    switch (data_bits)
+    {
+    case 5:
+        tty.c_cflag |= CS5;
+        break;
+    case 6:
+        tty.c_cflag |= CS6;
+        break;
+    case 7:
+        tty.c_cflag |= CS7;
+        break;
+    default:
+        tty.c_cflag |= CS8;
+        break;
+    }
+
+    // Parity
+    if (parity == 0)
+    {
+        tty.c_cflag &= ~PARENB;
+    }
+    else
+    {
+        tty.c_cflag |= PARENB;
+        if (parity == 1)
+        {
+            tty.c_cflag &= ~PARODD; // even
+        }
+        else
+        {
+            tty.c_cflag |= PARODD; // odd
+        }
+    }
+
+    // Stop bits
+    if (stop_bits == 2)
+    {
+        tty.c_cflag |= CSTOPB;
+    }
+    else
+    {
+        tty.c_cflag &= ~CSTOPB;
+    }
+
+    // Raw mode (no processing)
+    tty.c_iflag = 0;
+    tty.c_oflag = 0;
+    tty.c_lflag = 0;
+
+    tty.c_cc[VMIN]  = 0; // Non-blocking by default
+    tty.c_cc[VTIME] = 10; // 1 s read timeout
+
+    if (tcsetattr(fd, TCSANOW, &tty) != 0)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kSetStateError),
+            "serialOpen: Failed to configure port",
+            error_callback
+        );
+        close(fd);
+        delete handle;
+        return std::to_underlying(cpp_core::StatusCodes::kSetStateError);
+    }
+
+    return reinterpret_cast<intptr_t>(handle);
+}
diff --git a/src/serial_out_bytes_total.cpp b/src/serial_out_bytes_total.cpp
new file mode 100644
index 0000000..7826447
--- /dev/null
+++ b/src/serial_out_bytes_total.cpp
@@ -0,0 +1,21 @@
+#include "cpp_core/error_callback.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_out_bytes_total.h>
+#include <cstdint>
+#include <mutex>
+
+using namespace serial_internal;
+
+extern "C" auto serialOutBytesTotal(int64_t handle_ptr, ErrorCallbackT /*error_callback*/
+                                    ) -> int64_t
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        return 0;
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+    return handle->tx_total;
+}
diff --git a/src/serial_out_bytes_waiting.cpp b/src/serial_out_bytes_waiting.cpp
new file mode 100644
index 0000000..c70d167
--- /dev/null
+++ b/src/serial_out_bytes_waiting.cpp
@@ -0,0 +1,43 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_out_bytes_waiting.h>
+#include <cstdint>
+#include <mutex>
+#include <sys/ioctl.h>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialOutBytesWaiting(int64_t handle_ptr, ErrorCallbackT error_callback) -> int
+{
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialOutBytesWaiting: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+
+    int queued = 0;
+#ifdef TIOCOUTQ
+    if (ioctl(handle->fd, TIOCOUTQ, &queued) == -1)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kGetStateError),
+            "serialOutBytesWaiting: ioctl failed",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kGetStateError);
+    }
+#else
+    queued = 0;
+#endif
+    return queued;
+}
diff --git a/src/serial_read.cpp b/src/serial_read.cpp
new file mode 100644
index 0000000..5376e4a
--- /dev/null
+++ b/src/serial_read.cpp
@@ -0,0 +1,61 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_read.h>
+#include <cstdint>
+#include <mutex>
+#include <sys/types.h>
+#include <unistd.h>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialRead(int64_t handle_ptr, void *buffer, int buffer_size, int timeout_ms, int /*multiplier*/,
+                           ErrorCallbackT error_callback) -> int
+{
+    if (buffer == nullptr || buffer_size <= 0)
+    {
+        return std::to_underlying(cpp_core::StatusCodes::kBufferError);
+    }
+
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError), "serialRead: Invalid handle", error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+
+    // Abort requested from another thread?
+    if (handle->abort_read.exchange(false))
+    {
+        return std::to_underlying(cpp_core::StatusCodes::kAbortReadError);
+    }
+
+    if (waitFdReady(handle->fd, timeout_ms, false) <= 0)
+    {
+        return 0; // timeout or error -> treat as timeout, returning 0 bytes
+    }
+
+    ssize_t const bytes_read_system = ::read(handle->fd, buffer, buffer_size);
+    if (bytes_read_system < 0)
+    {
+        invokeError(std::to_underlying(cpp_core::StatusCodes::kReadError), "serialRead: Read error", error_callback);
+        return std::to_underlying(cpp_core::StatusCodes::kReadError);
+    }
+
+    if (bytes_read_system > 0)
+    {
+        handle->rx_total += bytes_read_system;
+        if (g_read_callback != nullptr)
+        {
+            g_read_callback(static_cast<int>(bytes_read_system));
+        }
+    }
+
+    return static_cast<int>(bytes_read_system);
+}
diff --git a/src/serial_read_until.cpp b/src/serial_read_until.cpp
new file mode 100644
index 0000000..38808dc
--- /dev/null
+++ b/src/serial_read_until.cpp
@@ -0,0 +1,53 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_read.h>
+#include <cpp_core/interface/serial_read_until.h>
+#include <cstdint>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialReadUntil(int64_t handle_ptr, void *buffer, int buffer_size, int timeout_ms, int multiplier,
+                                void *until_char_ptr, ErrorCallbackT error_callback) -> int
+{
+    if (buffer == nullptr || buffer_size <= 0 || until_char_ptr == nullptr)
+    {
+        return std::to_underlying(cpp_core::StatusCodes::kBufferError);
+    }
+
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialReadUntil: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    char const terminator = *static_cast<char *>(until_char_ptr);
+    char *char_buf   = static_cast<char *>(buffer);
+    int   total      = 0;
+
+    while (total < buffer_size)
+    {
+        int const bytes = serialRead(handle_ptr, char_buf + total, 1, timeout_ms, multiplier, error_callback);
+        if (bytes <= 0)
+        {
+            // timeout or error – propagate (if error negative, return negative)
+            return (bytes == 0) ? total : bytes;
+        }
+
+        if (char_buf[total] == terminator)
+        {
+            ++total;
+            break;
+        }
+        ++total;
+    }
+
+    return total;
+}
diff --git a/src/serial_read_until_sequence.cpp b/src/serial_read_until_sequence.cpp
new file mode 100644
index 0000000..840ec9e
--- /dev/null
+++ b/src/serial_read_until_sequence.cpp
@@ -0,0 +1,69 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_read.h>
+#include <cpp_core/interface/serial_read_until_sequence.h>
+#include <cstdint>
+#include <cstring>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialReadUntilSequence(int64_t handle_ptr, void *buffer, int buffer_size, int timeout_ms,
+                                        int multiplier, void *sequence_ptr, ErrorCallbackT error_callback) -> int
+{
+    if (buffer == nullptr || buffer_size <= 0 || sequence_ptr == nullptr)
+    {
+        return std::to_underlying(cpp_core::StatusCodes::kBufferError);
+    }
+
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialReadUntilSequence: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    const char *sequence_cstr = static_cast<const char *>(sequence_ptr);
+    const int   seq_len       = static_cast<int>(std::strlen(sequence_cstr));
+    if (seq_len == 0 || buffer_size < seq_len)
+    {
+        return 0;
+    }
+
+    char *char_buf = static_cast<char *>(buffer);
+    int   total    = 0;
+    int   matched  = 0;
+
+    while (total < buffer_size)
+    {
+        int const bytes = serialRead(handle_ptr, char_buf + total, 1, timeout_ms, multiplier, error_callback);
+        if (bytes <= 0)
+        {
+            return (bytes == 0) ? total : bytes;
+        }
+
+        char const current = char_buf[total];
+        ++total;
+
+        if (current == sequence_cstr[matched])
+        {
+            ++matched;
+            if (matched == seq_len)
+            {
+                break; // fully matched
+            }
+        }
+        else
+        {
+            matched = (current == sequence_cstr[0]) ? 1 : 0;
+        }
+    }
+
+    return total;
+}
diff --git a/src/serial_set_error_callback.cpp b/src/serial_set_error_callback.cpp
new file mode 100644
index 0000000..0e8e856
--- /dev/null
+++ b/src/serial_set_error_callback.cpp
@@ -0,0 +1,9 @@
+#include "cpp_core/error_callback.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_set_error_callback.h>
+
+extern "C" void serialSetErrorCallback(ErrorCallbackT error_callback)
+{
+    serial_internal::g_error_callback = error_callback;
+}
diff --git a/src/serial_set_read_callback.cpp b/src/serial_set_read_callback.cpp
new file mode 100644
index 0000000..17ec80b
--- /dev/null
+++ b/src/serial_set_read_callback.cpp
@@ -0,0 +1,8 @@
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_set_read_callback.h>
+
+extern "C" void serialSetReadCallback(void (*callback_fn)(int))
+{
+    serial_internal::g_read_callback = callback_fn;
+}
diff --git a/src/serial_set_write_callback.cpp b/src/serial_set_write_callback.cpp
new file mode 100644
index 0000000..da572a4
--- /dev/null
+++ b/src/serial_set_write_callback.cpp
@@ -0,0 +1,8 @@
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_set_write_callback.h>
+
+extern "C" void serialSetWriteCallback(void (*callback_fn)(int))
+{
+    serial_internal::g_write_callback = callback_fn;
+}
diff --git a/src/serial_state.cpp b/src/serial_state.cpp
new file mode 100644
index 0000000..c510f67
--- /dev/null
+++ b/src/serial_state.cpp
@@ -0,0 +1,9 @@
+#include "cpp_core/error_callback.h"
+#include "serial_internal.hpp"
+
+namespace serial_internal
+{
+ErrorCallbackT g_error_callback = nullptr;
+void (*g_read_callback)(int)    = nullptr;
+void (*g_write_callback)(int)   = nullptr;
+} // namespace serial_internal
diff --git a/src/serial_write.cpp b/src/serial_write.cpp
new file mode 100644
index 0000000..2e4ec54
--- /dev/null
+++ b/src/serial_write.cpp
@@ -0,0 +1,63 @@
+#include "cpp_core/error_callback.h"
+#include "cpp_core/status_codes.h"
+#include "serial_internal.hpp"
+
+#include <cpp_core/interface/serial_write.h>
+#include <cstdint>
+#include <mutex>
+#include <sys/types.h>
+#include <unistd.h>
+#include <utility>
+
+using namespace serial_internal;
+
+extern "C" auto serialWrite(int64_t handle_ptr, const void *buffer, int buffer_size, int timeout_ms, int /*multiplier*/,
+                            ErrorCallbackT error_callback) -> int
+{
+    if (buffer == nullptr || buffer_size <= 0)
+    {
+        return std::to_underlying(cpp_core::StatusCodes::kBufferError);
+    }
+
+    auto *handle = reinterpret_cast<SerialPortHandle *>(handle_ptr);
+    if (handle == nullptr)
+    {
+        invokeError(
+            std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError),
+            "serialWrite: Invalid handle",
+            error_callback
+        );
+        return std::to_underlying(cpp_core::StatusCodes::kInvalidHandleError);
+    }
+
+    std::scoped_lock const guard(handle->mtx);
+
+    // Abort?
+    if (handle->abort_write.exchange(false))
+    {
+        return std::to_underlying(cpp_core::StatusCodes::kAbortWriteError);
+    }
+
+    if (waitFdReady(handle->fd, timeout_ms, true) <= 0)
+    {
+        return 0; // timeout
+    }
+
+    ssize_t const bytes_written = ::write(handle->fd, buffer, buffer_size);
+    if (bytes_written < 0)
+    {
+        invokeError(std::to_underlying(cpp_core::StatusCodes::kWriteError), "serialWrite: Write error", error_callback);
+        return std::to_underlying(cpp_core::StatusCodes::kWriteError);
+    }
+
+    if (bytes_written > 0)
+    {
+        handle->tx_total += bytes_written;
+        if (g_write_callback != nullptr)
+        {
+            g_write_callback(static_cast<int>(bytes_written));
+        }
+    }
+
+    return static_cast<int>(bytes_written);
+}
diff --git a/src/status_codes.h b/src/status_codes.h
deleted file mode 100644
index 3eabfd8..0000000
--- a/src/status_codes.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-enum class StatusCodes {
-  SUCCESS = 0,
-  CLOSE_HANDLE_ERROR = -1,
-  INVALID_HANDLE_ERROR = -2,
-  READ_ERROR = -3,
-  WRITE_ERROR = -4,
-  GET_STATE_ERROR = -5,
-  SET_STATE_ERROR = -6,
-  SET_TIMEOUT_ERROR = -7,
-  BUFFER_ERROR = -8,
-  NOT_FOUND_ERROR = -9,
-  CLEAR_BUFFER_IN_ERROR = -10,
-  CLEAR_BUFFER_OUT_ERROR = -11,
-  ABORT_READ_ERROR = -12,
-  ABORT_WRITE_ERROR = -13,
-};
diff --git a/tests/serial_test.cpp b/tests/serial_test.cpp
index 71a795f..5fe69d9 100644
--- a/tests/serial_test.cpp
+++ b/tests/serial_test.cpp
@@ -1,4 +1,4 @@
-// Simple integration test for CPP-Unix-Bindings
+// Simple integration test for cpp_unix_bindings
 // ------------------------------------------------
 // This executable opens the given serial port, sends a test
 // string and verifies that the same string is echoed back
@@ -27,10 +27,9 @@
 */
 // ------------------------------------------------
 
-#include "serial.h"
-
 #include <array>
 #include <chrono>
+#include <cpp_core/serial.h>
 #include <cstring>
 #include <gtest/gtest.h>
 #include <string>
@@ -38,14 +37,17 @@
 
 namespace
 {
-const char* default_port = "/dev/ttyUSB0";
+const char *default_port = "/dev/ttyUSB0";
 } // namespace
 
-TEST(SerialEchoTest, EchoMessage)
+TEST(
+    SerialEchoTest,
+    EchoMessage
+)
 {
     const std::string test_msg = "HELLO";
 
-    intptr_t handle = serialOpen((void*)default_port, 115200, 8, 0, 0);
+    intptr_t handle = serialOpen((void *)default_port, 115200, 8, 0, 0);
     ASSERT_NE(handle, 0) << "Failed to open port " << default_port;
 
     // Opening a serial connection toggles DTR on most Arduino boards, which
@@ -54,36 +56,40 @@ TEST(SerialEchoTest, EchoMessage)
     std::this_thread::sleep_for(std::chrono::seconds(2));
 
     // Send message
-    int written = serialWrite(handle, (void*)test_msg.c_str(), static_cast<int>(test_msg.size()), 100, 1);
+    int written = serialWrite(handle, (void *)test_msg.c_str(), static_cast<int>(test_msg.size()), 100, 1);
     ASSERT_EQ(written, static_cast<int>(test_msg.size())) << "Write failed";
 
     // Read echo
-    char buffer[16] = {0};
-    int read_bytes = serialRead(handle, buffer, static_cast<int>(test_msg.size()), 500, 1);
-    ASSERT_EQ(read_bytes, static_cast<int>(test_msg.size())) << "Read failed (got " << read_bytes << ")";
+    std::array<char, 16> read_buffer{};
+    int                  bytes_read = serialRead(handle, read_buffer.data(), static_cast<int>(test_msg.size()), 500, 1);
+    ASSERT_EQ(bytes_read, static_cast<int>(test_msg.size())) << "Read failed (got " << bytes_read << ")";
 
-    ASSERT_EQ(std::strncmp(buffer, test_msg.c_str(), test_msg.size()), 0) << "Data mismatch: expected " << test_msg << ", got " << buffer;
+    ASSERT_EQ(std::strncmp(read_buffer.data(), test_msg.c_str(), test_msg.size()), 0)
+        << "Data mismatch: expected " << test_msg << ", got " << read_buffer.data();
 
     serialClose(handle);
 }
 
-TEST(SerialReadUntilTest, ReadUntilChar)
+TEST(
+    SerialReadUntilTest,
+    ReadUntilChar
+)
 {
     const std::string test_msg = "WORLD\n"; // include terminator newline
 
-    intptr_t handle = serialOpen((void*)default_port, 115200, 8, 0, 0);
+    intptr_t handle = serialOpen((void *)default_port, 115200, 8, 0, 0);
     ASSERT_NE(handle, 0) << "Failed to open port " << default_port;
 
     // Give the board time to reset after opening the port.
     std::this_thread::sleep_for(std::chrono::seconds(2));
 
     // Send message (write includes the terminator char)
-    int written = serialWrite(handle, (void*)test_msg.c_str(), static_cast<int>(test_msg.size()), 100, 1);
+    int written = serialWrite(handle, (void *)test_msg.c_str(), static_cast<int>(test_msg.size()), 100, 1);
     ASSERT_EQ(written, static_cast<int>(test_msg.size())) << "Write failed";
 
     // Read back until newline (inclusive)
     std::array<char, 32> buffer{0};
-    char until = '\n';
+    char                 until = '\n';
     int read_bytes = serialReadUntil(handle, buffer.data(), static_cast<int>(buffer.size()), 500, 1, &until);
     ASSERT_EQ(read_bytes, static_cast<int>(test_msg.size())) << "serialReadUntil returned unexpected length";
 
@@ -93,7 +99,10 @@ TEST(SerialReadUntilTest, ReadUntilChar)
     serialClose(handle);
 }
 
-int main(int argc, char** argv)
+int main(
+    int    argc,
+    char **argv
+)
 {
     ::testing::InitGoogleTest(&argc, argv);
     if (argc > 1)
diff --git a/tests/serial_unit_tests.cpp b/tests/serial_unit_tests.cpp
index dcfd6b6..c2455d3 100644
--- a/tests/serial_unit_tests.cpp
+++ b/tests/serial_unit_tests.cpp
@@ -1,114 +1,183 @@
-#include "serial.h"
-#include "status_codes.h"
-
+#include <array>
 #include <atomic>
-#include <cstring>
+#include <chrono>
+#include <cpp_core/interface/serial_set_error_callback.h>
+#include <cpp_core/serial.h>
+#include <cpp_core/status_codes.h>
+#include <cstdlib>
+#include <fcntl.h>
 #include <gtest/gtest.h>
 #include <iostream>
+#include <stdexcept>
+#include <string_view>
+#include <thread>
+#include <unistd.h>
+
+// Kleine Helfer für neue API --------------------------------------------------
+
+// Wrap der früher vorhandenen Funktion serialWriteLine
+static int serialWriteLine(
+    int64_t     handle,
+    const void *buffer,
+    int         buffer_size,
+    int         timeout_ms
+)
+{
+    int written = serialWrite(handle, buffer, buffer_size, timeout_ms, 1);
+    if (written != buffer_size)
+    {
+        return written; // Fehler
+    }
+    const char nl         = '\n';
+    int        nl_written = serialWrite(handle, &nl, 1, timeout_ms, 1);
+    return (nl_written == 1) ? (written + 1) : written;
+}
+
+// Alias für die neue Callback-Registrierung (ersetzt serialOnError)
+static void serialOnError(ErrorCallbackT cb)
+{
+    serialSetErrorCallback(cb);
+}
 
 namespace
 {
 // Helper storage for callback tests
-std::atomic<int>* g_err_ptr = nullptr;
+std::atomic<int> *g_err_ptr = nullptr;
 
-void errorCallback(int code)
+void errorCallback(
+    int code,
+    const char * /*message*/
+)
 {
     if (g_err_ptr != nullptr)
     {
         *g_err_ptr = code;
     }
 }
-} // namespace
 
-// ------------------------------- Error path --------------------------------
-TEST(SerialOpenTest, InvalidPathInvokesErrorCallback)
+// Helper to resolve serial port path (env var override)
+const char *getDefaultPort()
 {
-    std::atomic<int> err_code{0};
+    const char *env = std::getenv("SERIAL_PORT");
+    return (env != nullptr) ? env : "/dev/ttyUSB0";
+}
 
-    g_err_ptr = &err_code;
-    serialOnError(errorCallback);
+struct SerialDevice
+{
+    intptr_t    handle{0};
+    const char *port{nullptr};
 
-    intptr_t handle = serialOpen((void*)"/dev/__does_not_exist__", 115200, 8, 0, 0);
-    EXPECT_EQ(handle, 0);
-    EXPECT_EQ(err_code.load(), static_cast<int>(StatusCodes::INVALID_HANDLE_ERROR));
+    explicit SerialDevice(int baud = 115200)
+    {
+        port   = getDefaultPort();
+        handle = serialOpen((void *)port, baud, 8, 0, 0);
+        if (handle == 0)
+        {
+            throw std::runtime_error(std::string{"Failed to open port "} + port);
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // give Arduino time to reboot after DTR toggle
+    }
 
-    // Reset to nullptr so other tests don't see our callback
-    serialOnError(nullptr);
-}
+    ~SerialDevice()
+    {
+        if (handle != 0)
+        {
+            serialClose(handle);
+        }
+    }
 
-// ------------------------ serialGetPortsInfo checks ------------------------
-TEST(SerialGetPortsInfoTest, BufferTooSmallTriggersError)
+    void writeToDevice(std::string_view data) const
+    {
+        serialWrite(handle, data.data(), static_cast<int>(data.size()), 500, 1);
+    }
+};
+
+} // namespace
+
+// ------------------------------- Error path --------------------------------
+TEST(
+    SerialOpenTest,
+    InvalidPathInvokesErrorCallback
+)
 {
-    char sep[] = ";";
-    char buffer[4];
     std::atomic<int> err_code{0};
 
     g_err_ptr = &err_code;
     serialOnError(errorCallback);
 
-    int res = serialGetPortsInfo(buffer, sizeof(buffer), sep);
-    EXPECT_EQ(res, 0); // function indicates failure via 0
-    EXPECT_EQ(err_code.load(), static_cast<int>(StatusCodes::BUFFER_ERROR));
+    intptr_t handle = serialOpen((void *)"/dev/__does_not_exist__", 115200, 8, 0, 0);
+    EXPECT_LT(handle, 0);
+    EXPECT_EQ(err_code.load(), static_cast<int>(cpp_core::StatusCodes::kInvalidHandleError));
 
+    // Reset to nullptr so other tests don't see our callback
     serialOnError(nullptr);
 }
 
-TEST(SerialGetPortsInfoTest, LargeBufferReturnsZeroOrOne)
+// ------------------------ serialGetPortsInfo checks ------------------------
+TEST(
+    SerialGetPortsInfoTest,
+    CallbackReceivesPortInfo
+)
 {
-    char sep[] = ";";
-    char buffer[4096] = {0};
+    // Counter for how many times the callback is invoked
+    static int callback_count = 0;
+    callback_count            = 0;
+
+    auto callback_func = [](const char * /*port*/,
+                            const char * /*path*/,
+                            const char * /*manufacturer*/,
+                            const char * /*serialNumber*/,
+                            const char * /*pnpId*/,
+                            const char * /*locationId*/,
+                            const char * /*productId*/,
+                            const char * /*vendorId*/) { ++callback_count; };
 
     std::atomic<int> err_code{0};
     g_err_ptr = &err_code;
     serialOnError(errorCallback);
 
-    int res = serialGetPortsInfo(buffer, sizeof(buffer), sep);
-    EXPECT_GE(res, 0);
-    // res is 0 (no ports) or 1 (ports found)
-    EXPECT_LE(res, 1);
-    // Acceptable error codes: none or NOT_FOUND_ERROR (e.g., dir missing)
+    int result = serialListPorts(callback_func);
+
+    // result should match the number of times our callback ran
+    EXPECT_EQ(result, callback_count);
+
+    // Acceptable error codes: none or NOT_FOUND_ERROR (e.g., dir missing on CI)
     if (err_code != 0)
     {
-        EXPECT_EQ(err_code.load(), static_cast<int>(StatusCodes::NOT_FOUND_ERROR));
+        EXPECT_EQ(err_code.load(), static_cast<int>(cpp_core::StatusCodes::kNotFoundError));
     }
 
     serialOnError(nullptr);
 }
 
 // ---------------------------- Port listing helper ---------------------------
-TEST(SerialGetPortsInfoTest, PrintAvailablePorts)
+TEST(
+    SerialGetPortsInfoTest,
+    PrintAvailablePorts
+)
 {
-    char sep[] = ";";
-    char buffer[4096] = {0};
-
-    int res = serialGetPortsInfo(buffer, sizeof(buffer), sep);
-    EXPECT_GE(res, 0);
-
-    std::string ports_str(buffer);
-    if (!ports_str.empty())
-    {
-        std::cout << "\nAvailable serial ports (by-id):\n";
-        size_t start = 0;
-        while (true)
-        {
-            size_t pos = ports_str.find(sep, start);
-            std::string token = ports_str.substr(start, pos - start);
-            std::cout << "  " << token << "\n";
-            if (pos == std::string::npos)
-            {
-                break;
-            }
-            start = pos + std::strlen(sep);
-        }
-    }
-    else
+    auto print_callback = [](const char *port,
+                             const char *path,
+                             const char * /*manufacturer*/,
+                             const char * /*serialNumber*/,
+                             const char * /*pnpId*/,
+                             const char * /*locationId*/,
+                             const char * /*productId*/,
+                             const char * /*vendorId*/) { std::cout << "  " << port << " (alias: " << path << ")\n"; };
+
+    int result = serialListPorts(print_callback);
+    EXPECT_GE(result, 0);
+    if (result == 0)
     {
         std::cout << "\nNo serial devices found in /dev/serial/by-id\n";
     }
 }
 
 // --------------------------- Stubbed no-op APIs ----------------------------
-TEST(SerialStubbedFunctions, DoNotCrash)
+TEST(
+    SerialStubbedFunctions,
+    DoNotCrash
+)
 {
     serialClearBufferIn(0);
     serialClearBufferOut(0);
@@ -116,3 +185,71 @@ TEST(SerialStubbedFunctions, DoNotCrash)
     serialAbortWrite(0);
     SUCCEED(); // reached here without segfaults
 }
+
+TEST(
+    SerialHelpers,
+    ReadUntilToken
+)
+{
+    SerialDevice      dev;
+    const std::string payload = "ABC_OK";
+    dev.writeToDevice(payload);
+
+    std::array<char, 64>       read_buffer{};
+    constexpr std::string_view ok_token{"OK"};
+    int                        num_read = serialReadUntilSequence(
+        dev.handle,
+        read_buffer.data(),
+        static_cast<int>(read_buffer.size()),
+        2000,
+        1, // multiplier
+        (void *)ok_token.data()
+    );
+    ASSERT_EQ(num_read, static_cast<int>(payload.size()));
+    ASSERT_EQ(std::string_view(read_buffer.data(), num_read), payload);
+}
+
+TEST(
+    SerialHelpers,
+    Statistics
+)
+{
+    SerialDevice      dev;
+    const std::string payload = "0123456789";
+
+    // Transmit to device
+    int written = serialWrite(dev.handle, payload.c_str(), static_cast<int>(payload.size()), 2000, 1);
+    ASSERT_EQ(written, static_cast<int>(payload.size()));
+
+    // Drain and read echo back
+    serialDrain(dev.handle);
+
+    std::array<char, 16> read_buffer{};
+    int bytes_read = serialRead(dev.handle, read_buffer.data(), static_cast<int>(payload.size()), 2000, 1);
+    ASSERT_EQ(bytes_read, static_cast<int>(payload.size()));
+
+    ASSERT_EQ(serialOutBytesTotal(dev.handle), static_cast<int64_t>(payload.size()));
+    ASSERT_EQ(serialInBytesTotal(dev.handle), static_cast<int64_t>(payload.size()));
+}
+
+TEST(
+    SerialHelpers,
+    Drain
+)
+{
+    SerialDevice      dev;
+    const std::string payload = "TEXT";
+    int               written = serialWriteLine(dev.handle, payload.c_str(), static_cast<int>(payload.size()), 2000);
+    ASSERT_GT(written, 0);
+    ASSERT_EQ(serialDrain(dev.handle), 0);
+}
+
+TEST(
+    SerialHelpers,
+    Version
+)
+{
+    EXPECT_EQ(cpp_core::kVersion.major, 1U);
+    EXPECT_EQ(cpp_core::kVersion.minor, 0U);
+    EXPECT_EQ(cpp_core::kVersion.patch, 0U);
+}
diff --git a/versioning/version_config.cpp.in b/versioning/version_config.cpp.in
deleted file mode 100644
index 8d095d8..0000000
--- a/versioning/version_config.cpp.in
+++ /dev/null
@@ -1,14 +0,0 @@
-unsigned int getMajorVersion()
-{
-    return @VERSION_MAJOR@;
-}
-
-unsigned int getMinorVersion()
-{
-    return @VERSION_MINOR@;
-}
-
-unsigned int getPatchVersion()
-{
-    return @VERSION_PATCH@;
-}
\ No newline at end of file