Modifications and Improvements

- float->int8 43.7% reduction in scheme usage case
- Added contribution guidelines for contributing to the project, emphasizing human authorship and the use of AI in development.
- error refactoring
- added OrderedMap and other related methods,  now SMap requires OrderedMap to properly encode and decode
- implements MultiCheckNames with bit-level byte array, introduces SMapRepeat
- MultiCheck now uses bit-packed byte arrays instead of tuple-of-bools,
  reducing encoded buffer size and eliminating redundant framing overhead.
- Added SMapRepeat to support repeated map structures with cleaner semantics
  and more efficient encoding.
- Added SLang and also Custom json Scheme for users

Author: quickwritereader

.github/FUNDING.yml

@@ -0,0 +1,17 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
+custom: ['https://github.com/quickwritereader/PackOS#sponsorship', 'https://3xpl.com/litecoin/address/ltc1qqx8e6yl95gxlwqv52mwdt9f76euvls5fvt4ckd', ]
+

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,20 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG]"
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Additional context**
+Add any other context about the problem here.

CONTRIBUTING.md

@@ -0,0 +1,9 @@
+## Contributing to PackOS
+
+We welcome contributions! To maintain the integrity and ownership of the protocol, please follow these guidelines:
+
+* **Human-First Logic:** All core architectural decisions, protocol designs, and initial implementations must be authored by humans.
+* **Assisted Development:** AI can be used to redo, port, or refactor existing human-written logic, and it is advised to use AI for generating documentation and issues.
+* **Transparency:** When submitting a Pull Request, please note if AI was used for scaffolding or refactoring to help maintain clear attribution history.
+
+---

README.md

@@ -318,6 +318,58 @@ expectedFlat := map[string]any{
 fmt.Println("DecodedFlat:", decodedFlat)
 ```
 
+```go
+// Encode with schema example
+expected := pack.Pack(
+	pack.PackTuple(
+		pack.PackInt32(2025),
+		pack.PackBool(false),
+		pack.PackString("az"),
+	),
+	pack.PackTuple(
+		pack.PackInt16(7),
+		pack.PackBool(true),
+		pack.PackString("go"),
+	),
+)
+
+// Schema with named tuples
+chain := SchemeNamedChain{
+	SchemeChain: SChain(
+		STupleNamed(
+			[]string{"year", "flag", "code"},
+			SInt32,
+			SBool,
+			SStringLen(len("az")),
+		),
+		STupleNamed(
+			[]string{"num", "flag", "lang"},
+			SInt16,
+			SBool,
+			SStringLen(len("go")),
+		),
+	),
+	FieldNames: []string{"firstTuple", "secondTuple"},
+}
+
+// Value to encode: map with named fields
+val := map[string]any{
+	"firstTuple": map[string]any{
+		"year": int32(2025),
+		"flag": false,
+		"code": "az",
+	},
+	"secondTuple": map[string]any{
+		"num":  int16(7),
+		"flag": true,
+		"lang": "go",
+	},
+}
+
+actual, err := EncodeValueNamed(val, chain) 
+fmt.Println("Encoded Named:", actual)
+```
+
 ```go
 // Define scheme in JSON form
 schemeJSON := SchemeJSON{
@@ -362,3 +414,4 @@ STuple(
 )
 
 ```
+

Sponsorship.md

@@ -0,0 +1,9 @@
+
+## Sponsorship
+
+
+If you find **PackOS** useful and would like to support, you can donate via **Litecoin (LTC)**. 
+
+**LTC Address:** `ltc1qqx8e6yl95gxlwqv52mwdt9f76euvls5fvt4ckd`
+> [!IMPORTANT]
+> Please ensure you are sending via the **Litecoin (LTC) network** only.

access/generic_decode.go

@@ -62,11 +62,11 @@ func DecodePrimitive(typ types.Type, buf []byte) (interface{}, error) {
 }
 
 // DecodeTupleGeneric: decode a []any from the current position in a SeqGetAccess.
-func DecodeTupleGeneric(seq *SeqGetAccess, root bool) ([]any, error) {
+// If root is true, the caller already consumed the tuple header.
+// If ordered is true, maps inside the tuple are decoded as *types.OrderedMapAny.
+func DecodeTupleGeneric(seq *SeqGetAccess, root bool, ordered bool) ([]any, error) {
 	nested := seq
-	pos := 0
 	if !root {
-
 		pos := seq.CurrentIndex()
 		typ, width, err := seq.PeekTypeWidth()
 		if err != nil {
@@ -82,57 +82,66 @@ func DecodeTupleGeneric(seq *SeqGetAccess, root bool) ([]any, error) {
 			}
 			return nil, nil
 		}
-
 		nested, err = seq.PeekNestedSeq()
 		if err != nil {
 			return nil, fmt.Errorf("DecodeTuple: nested peek failed at pos %d: %w", pos, err)
 		}
 	}
+
 	out := make([]any, 0, nested.ArgCount())
 	for i := 0; i < nested.ArgCount(); i++ {
 		valTyp, _, err := nested.PeekTypeWidth()
-
 		if err != nil {
-			return nil, fmt.Errorf("DecodeMapAny: nested value decode error at %d: %w", i+1, err)
-
+			return nil, fmt.Errorf("DecodeTuple: nested value peek error at %d: %w", i, err)
 		}
 		switch valTyp {
 		case types.TypeMap:
-			v, err := DecodeMapAny(nested) // delegate
+			var v any
+			if ordered {
+				v, err = DecodeOrderedMapAny(nested)
+			} else {
+				v, err = DecodeMapAny(nested)
+			}
 			if err != nil {
-				return nil, fmt.Errorf("DecodeMapAny: nested value decode error at %d: %w", i+1, err)
+				return nil, fmt.Errorf("DecodeTuple: nested map decode error at %d: %w", i, err)
 			}
 			out = append(out, v)
+
 		case types.TypeTuple:
-			v, err := DecodeTuple(nested) // delegate
+			v, err := DecodeTuple(nested)
 			if err != nil {
-				return nil, fmt.Errorf("DecodeMapAny: nested value decode error at %d: %w", i+1, err)
+				return nil, fmt.Errorf("DecodeTuple: nested tuple decode error at %d: %w", i, err)
 			}
 			out = append(out, v)
+
 		default:
 			valPayload, valTyp, err := nested.Next()
 			if err != nil {
-				return nil, fmt.Errorf("DecodeMapAny: nested value decode error at %d: %w", i+1, err)
+				return nil, fmt.Errorf("DecodeTuple: nested value next error at %d: %w", i, err)
 			}
 			v, err := DecodePrimitive(valTyp, valPayload)
-
 			if err != nil {
-				return nil, fmt.Errorf("DecodeMapAny: nested value decode error at %d: %w", i+1, err)
+				return nil, fmt.Errorf("DecodeTuple: primitive decode error at %d: %w", i, err)
 			}
 			out = append(out, v)
 		}
-
 	}
+
 	if !root {
 		if err := seq.Advance(); err != nil {
-			return nil, fmt.Errorf("DecodeTuple: advance failed at pos %d: %w", pos, err)
+			return nil, fmt.Errorf("DecodeTuple: advance failed: %w", err)
 		}
 	}
 	return out, nil
 }
 
+// Convenience wrappers
 func DecodeTuple(seq *SeqGetAccess) ([]any, error) {
-	return DecodeTupleGeneric(seq, false)
+	return DecodeTupleGeneric(seq, false, false)
+}
+
+func DecodeTupleOrdered(seq *SeqGetAccess) ([]any, error) {
+	return DecodeTupleGeneric(seq, false, true)
 }
 
 // DecodeMapAny: decode a map[string]any from the current position in a SeqGetAccess.
@@ -208,15 +217,91 @@ func DecodeMapAny(seq *SeqGetAccess) (map[string]any, error) {
 	return out, nil
 }
 
+// DecodeOrderedMapAny decodes a map from the sequence into an OrderedMapAny,
+// preserving insertion order of keys.
+func DecodeOrderedMapAny(seq *SeqGetAccess) (*types.OrderedMapAny, error) {
+	pos := seq.CurrentIndex()
+	typ, width, err := seq.PeekTypeWidth()
+	if err != nil {
+		return nil, fmt.Errorf("DecodeOrderedMapAny: peek failed at pos %d: %w", pos, err)
+	}
+	if typ != types.TypeMap {
+		return nil, fmt.Errorf("DecodeOrderedMapAny: type mismatch at pos %d — expected %v, got %v", pos, types.TypeMap, typ)
+	}
+	if width == 0 {
+		// nil/empty map
+		if err := seq.Advance(); err != nil {
+			return nil, fmt.Errorf("DecodeOrderedMapAny: advance failed at pos %d: %w", pos, err)
+		}
+		return nil, nil
+	}
+
+	nested, err := seq.PeekNestedSeq()
+	if err != nil {
+		return nil, fmt.Errorf("DecodeOrderedMapAny: nested peek failed at pos %d: %w", pos, err)
+	}
+
+	out := types.NewOrderedMapAny()
+	for i := 0; i < nested.ArgCount(); i += 2 {
+		// key
+		keyPayload, keyTyp, err := nested.Next()
+		if err != nil {
+			return nil, fmt.Errorf("DecodeOrderedMapAny: key decode error at %d: %w", i, err)
+		}
+		if keyTyp != types.TypeString {
+			return nil, fmt.Errorf("DecodeOrderedMapAny: map key not string at %d, got %v", i, keyTyp)
+		}
+		key := string(keyPayload)
+
+		valTyp, _, err := nested.PeekTypeWidth()
+		if err != nil {
+			return nil, fmt.Errorf("DecodeOrderedMapAny: nested value decode error at %d: %w", i+1, err)
+		}
+
+		switch valTyp {
+		case types.TypeMap:
+			v, err := DecodeOrderedMapAny(nested) // delegate recursively
+			if err != nil {
+				return nil, fmt.Errorf("DecodeOrderedMapAny: nested value decode error at %d: %w", i+1, err)
+			}
+			out.Set(key, v)
+
+		case types.TypeTuple:
+			v, err := DecodeTuple(nested)
+			if err != nil {
+				return nil, fmt.Errorf("DecodeOrderedMapAny: nested value decode error at %d: %w", i+1, err)
+			}
+			out.Set(key, v)
+
+		default:
+			valPayload, valTyp, err := nested.Next()
+			if err != nil {
+				return nil, fmt.Errorf("DecodeOrderedMapAny: nested value decode error at %d: %w", i+1, err)
+			}
+			v, err := DecodePrimitive(valTyp, valPayload)
+			if err != nil {
+				return nil, fmt.Errorf("DecodeOrderedMapAny: nested value decode error at %d: %w", i+1, err)
+			}
+			out.Set(key, v)
+		}
+	}
+
+	if err := seq.Advance(); err != nil {
+		return nil, fmt.Errorf("DecodeOrderedMapAny: advance failed at pos %d: %w", pos, err)
+	}
+	return out, nil
+}
+
 // Decode: convenience entry point for decoding a buffer that contains a top-level tuple.
+// Decode decodes a buffer into Go values.
+// Maps inside tuples are decoded as plain map[string]any.
 func Decode(buf []byte) (any, error) {
 	seq, err := NewSeqGetAccess(buf)
 	if err != nil {
 		return nil, fmt.Errorf("Decode: failed to create sequence: %w", err)
 	}
 
-	// delegate to tuple decoder
-	vals, err := DecodeTupleGeneric(seq, true)
+	vals, err := DecodeTupleGeneric(seq, true, false) // ordered=false
 	if err != nil {
 		return nil, fmt.Errorf("Decode: tuple decode failed: %w", err)
 	}
@@ -225,3 +310,21 @@ func Decode(buf []byte) (any, error) {
 	}
 	return vals, nil
 }
+
+// DecodeOrdered decodes a buffer into Go values.
+// Maps inside tuples are decoded as *types.OrderedMapAny.
+func DecodeOrdered(buf []byte) (any, error) {
+	seq, err := NewSeqGetAccess(buf)
+	if err != nil {
+		return nil, fmt.Errorf("DecodeOrdered: failed to create sequence: %w", err)
+	}
+
+	vals, err := DecodeTupleGeneric(seq, true, true) // ordered=true
+	if err != nil {
+		return nil, fmt.Errorf("DecodeOrdered: tuple decode failed: %w", err)
+	}
+	if len(vals) == 1 {
+		return vals[0], nil
+	}
+	return vals, nil
+}

access/get.go

@@ -419,6 +419,34 @@ func (g *GetAccess) GetMapAny(pos int) (map[string]any, error) {
 	return out, nil
 }
 
+// GetMapOrderedAny decodes a map at the given position into an OrderedMapAny,
+// preserving insertion order of keys.
+func (g *GetAccess) GetMapOrderedAny(pos int) (*types.OrderedMapAny, error) {
+	tp, start, end := g.rangeAt(pos)
+	if end < start || tp != types.TypeMap {
+		return nil, errors.New("decode error")
+	}
+	if end == start {
+		return nil, nil // nil map
+	}
+
+	nested := NewGetAccess(g.buf[start:end])
+	out := types.NewOrderedMapAny()
+
+	for i := 0; i < nested.argCount; i += 2 {
+		key, err := nested.GetString(i)
+		if err != nil {
+			return nil, fmt.Errorf("ordered map key decode error at %d: %w", i, err)
+		}
+		val, err := GetAny(nested, i+1)
+		if err != nil {
+			return nil, fmt.Errorf("ordered map value decode error at %d: %w", i+1, err)
+		}
+		out.Set(key, val)
+	}
+	return out, nil
+}
+
 func (g *GetAccess) GetMapStr(pos int) (map[string]string, error) {
 	tp, start, end := g.rangeAt(pos)
 	if end < start || tp != types.TypeMap {