From e4578937439051cf1a69f6caa8c9e70429093ab7 Mon Sep 17 00:00:00 2001 From: zeekay Date: Tue, 23 Jun 2026 15:05:15 -0700 Subject: [PATCH] rename v2 -> v1: the typed-view API + codegen is the canonical 1.0 (no v2, ever) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit There is one perfected typed ZAP layer and it lives at github.com/luxfi/zap/v1 — forwards-only, no backwards-compat baggage, never a breaking major. Mechanical, behavior-preserving: v2/ -> v1/ (git mv), package zapv2 -> zapv1, import path .../zap/v2 -> .../zap/v1 (incl. the codegen's emitted banner + import so generated files reference /v1). Codegen golden tests pass; typed layer vets clean. (Pre-existing CGO 'resolv' link failures in the root package are unrelated env noise.) --- builder.go | 2 +- doc.go | 2 +- {v2 => v1}/BENCH_RESULTS.md | 0 {v2 => v1}/IMPOSSIBILITY.md | 0 {v2 => v1}/README.md | 0 .../_compile_fail_test/cross_schema_field.go | 26 +-- {v2 => v1}/bench_test.go | 20 +-- {v2 => v1}/builder.go | 6 +- {v2 => v1}/codegen/README.md | 0 {v2 => v1}/codegen/cmd/zapgen-all/main.go | 2 +- .../codegen/cmd/zapgen-all/main_test.go | 0 {v2 => v1}/codegen/cmd/zapgen/main.go | 2 +- {v2 => v1}/codegen/doc.go | 10 +- {v2 => v1}/codegen/emit.go | 60 +++---- {v2 => v1}/codegen/emit_test.go | 30 ++-- {v2 => v1}/codegen/schema.go | 24 +-- .../codegen/schemas/lp-182-consensus.json | 0 {v2 => v1}/codegen/schemas/lp-186-vms.json | 0 {v2 => v1}/codegen/schemas/lp-201-p2p.json | 0 {v2 => v1}/codegen/schemas/lp-208-dag.json | 0 .../codegen/schemas/lp-211-cross-shard.json | 0 .../codegen/schemas/lp-214-light-client.json | 0 {v2 => v1}/codegen/schemas/lp-218-rollup.json | 0 .../testpkg/lc_block_header_request_zap.go | 56 +++---- .../testpkg/lp182_consensuswire/bench_test.go | 6 +- .../lp182_consensuswire/quasar_cert_zap.go | 82 +++++----- .../lp182_consensuswire/roundtrip_test.go | 24 +-- .../testpkg/lp186_zkvmwire/bench_test.go | 6 +- .../testpkg/lp186_zkvmwire/roundtrip_test.go | 20 +-- .../testpkg/lp186_zkvmwire/utxo_zap.go | 66 ++++---- {v2 => v1}/codegen/testpkg/roundtrip_test.go | 22 +-- {v2 => v1}/compile_fail_test.go | 2 +- {v2 => v1}/doc.go | 4 +- {v2 => v1}/examples/advance_time_tx.go | 64 ++++---- {v2 => v1}/examples/batch_tx.go | 58 +++---- {v2 => v1}/field.go | 14 +- {v2 => v1}/iter.go | 2 +- {v2 => v1}/list.go | 20 +-- {v2 => v1}/pool.go | 4 +- {v2 => v1}/registry.go | 6 +- {v2 => v1}/schema.go | 4 +- {v2 => v1}/v2_test.go | 154 +++++++++--------- {v2 => v1}/view.go | 2 +- zap.go | 10 +- 44 files changed, 405 insertions(+), 405 deletions(-) rename {v2 => v1}/BENCH_RESULTS.md (100%) rename {v2 => v1}/IMPOSSIBILITY.md (100%) rename {v2 => v1}/README.md (100%) rename {v2 => v1}/_compile_fail_test/cross_schema_field.go (72%) rename {v2 => v1}/bench_test.go (93%) rename {v2 => v1}/builder.go (97%) rename {v2 => v1}/codegen/README.md (100%) rename {v2 => v1}/codegen/cmd/zapgen-all/main.go (99%) rename {v2 => v1}/codegen/cmd/zapgen-all/main_test.go (100%) rename {v2 => v1}/codegen/cmd/zapgen/main.go (98%) rename {v2 => v1}/codegen/doc.go (89%) rename {v2 => v1}/codegen/emit.go (89%) rename {v2 => v1}/codegen/emit_test.go (90%) rename {v2 => v1}/codegen/schema.go (87%) rename {v2 => v1}/codegen/schemas/lp-182-consensus.json (100%) rename {v2 => v1}/codegen/schemas/lp-186-vms.json (100%) rename {v2 => v1}/codegen/schemas/lp-201-p2p.json (100%) rename {v2 => v1}/codegen/schemas/lp-208-dag.json (100%) rename {v2 => v1}/codegen/schemas/lp-211-cross-shard.json (100%) rename {v2 => v1}/codegen/schemas/lp-214-light-client.json (100%) rename {v2 => v1}/codegen/schemas/lp-218-rollup.json (100%) rename {v2 => v1}/codegen/testpkg/lc_block_header_request_zap.go (73%) rename {v2 => v1}/codegen/testpkg/lp182_consensuswire/bench_test.go (94%) rename {v2 => v1}/codegen/testpkg/lp182_consensuswire/quasar_cert_zap.go (66%) rename {v2 => v1}/codegen/testpkg/lp182_consensuswire/roundtrip_test.go (87%) rename {v2 => v1}/codegen/testpkg/lp186_zkvmwire/bench_test.go (94%) rename {v2 => v1}/codegen/testpkg/lp186_zkvmwire/roundtrip_test.go (89%) rename {v2 => v1}/codegen/testpkg/lp186_zkvmwire/utxo_zap.go (69%) rename {v2 => v1}/codegen/testpkg/roundtrip_test.go (90%) rename {v2 => v1}/compile_fail_test.go (98%) rename {v2 => v1}/doc.go (96%) rename {v2 => v1}/examples/advance_time_tx.go (77%) rename {v2 => v1}/examples/batch_tx.go (56%) rename {v2 => v1}/field.go (96%) rename {v2 => v1}/iter.go (99%) rename {v2 => v1}/list.go (94%) rename {v2 => v1}/pool.go (95%) rename {v2 => v1}/registry.go (97%) rename {v2 => v1}/schema.go (98%) rename {v2 => v1}/v2_test.go (72%) rename {v2 => v1}/view.go (99%) diff --git a/builder.go b/builder.go index b8acb2e..01ca1ce 100644 --- a/builder.go +++ b/builder.go @@ -282,7 +282,7 @@ func (ob *ObjectBuilder) ensureField(endOffset int) { // backwards). // // This is the exported counterpart to the internal ensureField helper. -// It is used by zapv2.WriteList to keep the parent's payload reserved +// It is used by zapv1.WriteList to keep the parent's payload reserved // before list elements are appended. func (ob *ObjectBuilder) ReserveFixed(dataSize int) { ob.ensureField(dataSize) diff --git a/doc.go b/doc.go index 2693403..1ba11e4 100644 --- a/doc.go +++ b/doc.go @@ -7,7 +7,7 @@ // which emits v1-equivalent fast paths from a declarative .zap source. // // Consumer dispatch for ad-hoc / dynamic schemas goes through the v2 -// generic API (github.com/luxfi/zap/v2). +// generic API (github.com/luxfi/zap/v1). // // The v1 hand-rolled code in this package remains for in-flight // migration of legacy callers (luxfi/node/vms/platformvm/txs/zap_native, diff --git a/v2/BENCH_RESULTS.md b/v1/BENCH_RESULTS.md similarity index 100% rename from v2/BENCH_RESULTS.md rename to v1/BENCH_RESULTS.md diff --git a/v2/IMPOSSIBILITY.md b/v1/IMPOSSIBILITY.md similarity index 100% rename from v2/IMPOSSIBILITY.md rename to v1/IMPOSSIBILITY.md diff --git a/v2/README.md b/v1/README.md similarity index 100% rename from v2/README.md rename to v1/README.md diff --git a/v2/_compile_fail_test/cross_schema_field.go b/v1/_compile_fail_test/cross_schema_field.go similarity index 72% rename from v2/_compile_fail_test/cross_schema_field.go rename to v1/_compile_fail_test/cross_schema_field.go index 040f16e..b0839d8 100644 --- a/v2/_compile_fail_test/cross_schema_field.go +++ b/v1/_compile_fail_test/cross_schema_field.go @@ -13,8 +13,8 @@ // Expected output (Go 1.23+): // // ./cross_schema_field.go:NN:NN: cannot use AlphaFields.X (variable -// of type zapv2.Field[AlphaSchema, uint64]) as -// zapv2.Field[BetaSchema, uint64] value in argument to zapv2.Read +// of type zapv1.Field[AlphaSchema, uint64]) as +// zapv1.Field[BetaSchema, uint64] value in argument to zapv1.Read // // The directory name begins with an underscore so `go build ./...` // at the v2 root skips it; only an explicit build path includes it, @@ -23,44 +23,44 @@ package compile_fail_demo import ( - "github.com/luxfi/zap/v2" + "github.com/luxfi/zap/v1" ) // AlphaSchema is one schema... type AlphaSchema struct{} -func (AlphaSchema) Kind() zapv2.KindByte { return 0xA1 } +func (AlphaSchema) Kind() zapv1.KindByte { return 0xA1 } func (AlphaSchema) Size() int { return 16 } func (AlphaSchema) Name() string { return "Alpha" } // BetaSchema is a different schema... type BetaSchema struct{} -func (BetaSchema) Kind() zapv2.KindByte { return 0xB1 } +func (BetaSchema) Kind() zapv1.KindByte { return 0xB1 } func (BetaSchema) Size() int { return 16 } func (BetaSchema) Name() string { return "Beta" } var ( AlphaFields = struct { - X zapv2.Field[AlphaSchema, uint64] - }{X: zapv2.At[AlphaSchema, uint64](1)} + X zapv1.Field[AlphaSchema, uint64] + }{X: zapv1.At[AlphaSchema, uint64](1)} BetaFields = struct { - Y zapv2.Field[BetaSchema, uint64] - }{Y: zapv2.At[BetaSchema, uint64](1)} + Y zapv1.Field[BetaSchema, uint64] + }{Y: zapv1.At[BetaSchema, uint64](1)} ) // crossSchemaRead is the load-bearing compile-time-safety // demonstration. The compiler MUST reject this because // AlphaFields.X is a Field[AlphaSchema, uint64] but the View is // View[BetaSchema] — the type parameters do not unify. -func crossSchemaRead(beta zapv2.View[BetaSchema]) uint64 { - return zapv2.Read(beta, AlphaFields.X) // COMPILE ERROR +func crossSchemaRead(beta zapv1.View[BetaSchema]) uint64 { + return zapv1.Read(beta, AlphaFields.X) // COMPILE ERROR } // crossTypeWrite tries to write an int64 into a Field declared for // uint64. The compiler MUST reject this because the value type does // not match the field's T parameter. -func crossTypeWrite(s zapv2.Setter[AlphaSchema]) { - zapv2.Write(s, AlphaFields.X, int64(42)) // COMPILE ERROR +func crossTypeWrite(s zapv1.Setter[AlphaSchema]) { + zapv1.Write(s, AlphaFields.X, int64(42)) // COMPILE ERROR } diff --git a/v2/bench_test.go b/v1/bench_test.go similarity index 93% rename from v2/bench_test.go rename to v1/bench_test.go index cf68fb6..69fea65 100644 --- a/v2/bench_test.go +++ b/v1/bench_test.go @@ -1,14 +1,14 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2_test +package zapv1_test import ( "testing" "github.com/luxfi/zap" - "github.com/luxfi/zap/v2" - "github.com/luxfi/zap/v2/examples" + "github.com/luxfi/zap/v1" + "github.com/luxfi/zap/v1/examples" ) // Benchmark baseline reference: @@ -34,8 +34,8 @@ import ( // changing the v2 API. // BenchmarkGeneric_Build_AdvanceTime builds the canary AdvanceTimeTx -// via the imperative-style v2 generic API ([zapv2.NewBuilderFor] + -// [zapv2.WriteB] + Finish). Targets matching v1's 1-alloc profile. +// via the imperative-style v2 generic API ([zapv1.NewBuilderFor] + +// [zapv1.WriteB] + Finish). Targets matching v1's 1-alloc profile. func BenchmarkGeneric_Build_AdvanceTime(b *testing.B) { b.ReportAllocs() for i := 0; i < b.N; i++ { @@ -76,7 +76,7 @@ func BenchmarkGeneric_Read_AdvanceTime(b *testing.B) { b.ReportAllocs() for i := 0; i < b.N; i++ { v, _ := examples.WrapAdvanceTime(buf) - _ = zapv2.Read(v, examples.AdvanceTimeFields.Time) + _ = zapv1.Read(v, examples.AdvanceTimeFields.Time) } } @@ -109,7 +109,7 @@ func BenchmarkGeneric_Read_NoParse(b *testing.B) { b.ReportAllocs() var sink uint64 for i := 0; i < b.N; i++ { - sink = zapv2.Read(view, examples.AdvanceTimeFields.Time) + sink = zapv1.Read(view, examples.AdvanceTimeFields.Time) } _ = sink } @@ -152,7 +152,7 @@ func BenchmarkGeneric_List_Range(b *testing.B) { for i := 0; i < b.N; i++ { var sum uint64 for v := range list.All() { - sum += zapv2.Read(v, examples.ItemFields.Value) + sum += zapv1.Read(v, examples.ItemFields.Value) } _ = sum } @@ -175,7 +175,7 @@ func BenchmarkGeneric_List_Range_Payloads(b *testing.B) { for i := 0; i < b.N; i++ { var sum uint64 for p := range list.Payloads() { - sum += zapv2.ReadPayload(p, examples.ItemFields.Value) + sum += zapv1.ReadPayload(p, examples.ItemFields.Value) } _ = sum } @@ -216,7 +216,7 @@ func BenchmarkHandRolled_List_Range(b *testing.B) { // have zero allocations per Get/Put pair once it's warm. func BenchmarkPool_GetPut(b *testing.B) { type Box struct{ N uint64 } - pool := zapv2.NewPool(func() *Box { return &Box{} }) + pool := zapv1.NewPool(func() *Box { return &Box{} }) // Warm up the pool. for i := 0; i < 100; i++ { pool.Put(pool.Get()) diff --git a/v2/builder.go b/v1/builder.go similarity index 97% rename from v2/builder.go rename to v1/builder.go index 5214940..60fa204 100644 --- a/v2/builder.go +++ b/v1/builder.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2 +package zapv1 import ( "github.com/luxfi/zap" @@ -16,8 +16,8 @@ import ( // // Usage: // -// bb := zapv2.NewBuilderFor[AdvanceTimeSchema]() -// zapv2.WriteB(bb, examples.AdvanceTimeFields.Time, ts) +// bb := zapv1.NewBuilderFor[AdvanceTimeSchema]() +// zapv1.WriteB(bb, examples.AdvanceTimeFields.Time, ts) // view, buf := bb.Finish() // // WriteB is the explicit-receiver counterpart to [Write] — both take diff --git a/v2/codegen/README.md b/v1/codegen/README.md similarity index 100% rename from v2/codegen/README.md rename to v1/codegen/README.md diff --git a/v2/codegen/cmd/zapgen-all/main.go b/v1/codegen/cmd/zapgen-all/main.go similarity index 99% rename from v2/codegen/cmd/zapgen-all/main.go rename to v1/codegen/cmd/zapgen-all/main.go index 0f0e450..8576a06 100644 --- a/v2/codegen/cmd/zapgen-all/main.go +++ b/v1/codegen/cmd/zapgen-all/main.go @@ -53,7 +53,7 @@ import ( "strconv" "strings" - "github.com/luxfi/zap/v2/codegen" + "github.com/luxfi/zap/v1/codegen" ) // schemaSpec is the JSON wire shape for a single schema. It is the diff --git a/v2/codegen/cmd/zapgen-all/main_test.go b/v1/codegen/cmd/zapgen-all/main_test.go similarity index 100% rename from v2/codegen/cmd/zapgen-all/main_test.go rename to v1/codegen/cmd/zapgen-all/main_test.go diff --git a/v2/codegen/cmd/zapgen/main.go b/v1/codegen/cmd/zapgen/main.go similarity index 98% rename from v2/codegen/cmd/zapgen/main.go rename to v1/codegen/cmd/zapgen/main.go index 65af0ae..723e2b9 100644 --- a/v2/codegen/cmd/zapgen/main.go +++ b/v1/codegen/cmd/zapgen/main.go @@ -22,7 +22,7 @@ import ( "strconv" "strings" - "github.com/luxfi/zap/v2/codegen" + "github.com/luxfi/zap/v1/codegen" ) type fieldFlag struct { diff --git a/v2/codegen/doc.go b/v1/codegen/doc.go similarity index 89% rename from v2/codegen/doc.go rename to v1/codegen/doc.go index 0c7dd10..639ed33 100644 --- a/v2/codegen/doc.go +++ b/v1/codegen/doc.go @@ -12,7 +12,7 @@ // into its caller, so the call site pays a function-call cost (~5-7 // ns on modern hardware). The work performed by a "Wrap" function // (parse the ZAP wire frame, validate the kind discriminator, build -// a typed view) exceeds that budget. The generic [zapv2.Wrap[S]] +// a typed view) exceeds that budget. The generic [zapv1.Wrap[S]] // function therefore costs one function call per Wrap, even when // every other primitive in its body would inline. // @@ -32,7 +32,7 @@ // For a schema declared as: // // type AdvanceTimeSchema struct{} -// func (AdvanceTimeSchema) Kind() zapv2.KindByte { return 1 } +// func (AdvanceTimeSchema) Kind() zapv1.KindByte { return 1 } // func (AdvanceTimeSchema) Size() int { return 9 } // func (AdvanceTimeSchema) Name() string { return "AdvanceTimeTx" } // @@ -44,7 +44,7 @@ // const kindAdvanceTimeTx uint8 = 1 // const offsetAdvanceTimeTx_Time = 1 // -// func WrapAdvanceTime(b []byte) (zapv2.View[AdvanceTimeSchema], error) { +// func WrapAdvanceTime(b []byte) (zapv1.View[AdvanceTimeSchema], error) { // msg, err := zap.Parse(b) // ... // } @@ -61,8 +61,8 @@ // file, a Cap'n-Proto-style schema file, struct tags) and want // ZAP v2 accessors emitted automatically. // -// For cold paths and ad-hoc schemas, the generic [zapv2.Wrap[S]] / -// [zapv2.Build[S]] are equally correct and one extra function call +// For cold paths and ad-hoc schemas, the generic [zapv1.Wrap[S]] / +// [zapv1.Build[S]] are equally correct and one extra function call // slower — which is rarely the bottleneck. // // # Status diff --git a/v2/codegen/emit.go b/v1/codegen/emit.go similarity index 89% rename from v2/codegen/emit.go rename to v1/codegen/emit.go index c02068f..dce1b5e 100644 --- a/v2/codegen/emit.go +++ b/v1/codegen/emit.go @@ -9,7 +9,7 @@ import ( "strings" ) -// typeToSize maps a [zapv2.FieldKind] Go type name to its byte width. +// typeToSize maps a [zapv1.FieldKind] Go type name to its byte width. // Used by the field-write code to pick the right ObjectBuilder.Set* // method. var typeToSize = map[string]int{ @@ -68,12 +68,12 @@ func fieldByteSize(f Field) (int, bool) { // v1 hand-rolled performance to within compiler noise — verified by // the bench suite. // -// Scalar fields go through the [zapv2.Field][S, T] generic handle +// Scalar fields go through the [zapv1.Field][S, T] generic handle // (declared in the per-schema Fields var). Fixed-width // byte-array fields ("bytes") are emitted as standalone typed // accessor functions that call v1's SetBytesFixed / BytesFixedSlice // — they do NOT appear in the Fields struct because [N]byte is not a -// [zapv2.FieldKind] member. Both forms produce the same wire layout. +// [zapv1.FieldKind] member. Both forms produce the same wire layout. func Emit(w io.Writer, s Schema) error { // Validate field types + offsets. for _, f := range s.Fields { @@ -109,21 +109,21 @@ func Emit(w io.Writer, s Schema) error { fmt.Fprintf(w, `// Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. // -// Code generated by github.com/luxfi/zap/v2/codegen — DO NOT EDIT. +// Code generated by github.com/luxfi/zap/v1/codegen — DO NOT EDIT. // Source schema: %s (kind=0x%02x, size=%d). package %s import ( "github.com/luxfi/zap" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) `, s.WireName, s.Kind, s.Size, s.Package) // Constants. fmt.Fprintf(w, `// Kind%s is the wire discriminator for %s. -const Kind%s zapv2.KindByte = 0x%02x +const Kind%s zapv1.KindByte = 0x%02x // Size%s is the fixed object payload size in bytes. const Size%s = %d @@ -133,11 +133,11 @@ const Size%s = %d // Schema marker type. fmt.Fprintf(w, `// %s is the v2 schema marker for %s. Methods are constant- -// returning so concrete-typed [zapv2.Wrap[%s]] calls fold to +// returning so concrete-typed [zapv1.Wrap[%s]] calls fold to // literals at the call site. type %s struct{} -func (%s) Kind() zapv2.KindByte { return Kind%s } +func (%s) Kind() zapv1.KindByte { return Kind%s } func (%s) Size() int { return Size%s } func (%s) Name() string { return %q } @@ -157,10 +157,10 @@ func (%s) Name() string { return %q } // Byte-array fields are handled by standalone accessor functions // (emitted after the constructor) because [N]byte is not a // FieldKind union member. - // Scalar fields go in the Fields struct (zapv2.Field handles). + // Scalar fields go in the Fields struct (zapv1.Field handles). // Fixed byte-arrays and variable-length tails (string/bytes) get // standalone typed accessors instead — neither [N]byte nor string/ - // []byte is a zapv2.FieldKind member. + // []byte is a zapv1.FieldKind member. var scalarFields []Field var accessorFields []Field for _, f := range s.Fields { @@ -174,15 +174,15 @@ func (%s) Name() string { return %q } if len(scalarFields) > 0 { fmt.Fprintf(w, "// %sFields is the namespace of every scalar field accessor for %s.\n", s.GoName, s.WireName) - fmt.Fprintf(w, "// Use with [zapv2.Read] / [zapv2.Write] for type-safe access.\n") + fmt.Fprintf(w, "// Use with [zapv1.Read] / [zapv1.Write] for type-safe access.\n") fmt.Fprintf(w, "// Byte-array fields are emitted as standalone functions, see below.\nvar %sFields = struct {\n", s.GoName) for _, f := range scalarFields { - fmt.Fprintf(w, "\t%s zapv2.Field[%s, %s]\n", f.Name, s.GoName, f.Type) + fmt.Fprintf(w, "\t%s zapv1.Field[%s, %s]\n", f.Name, s.GoName, f.Type) } fmt.Fprintf(w, "}{\n") for _, f := range scalarFields { - fmt.Fprintf(w, "\t%s: zapv2.At[%s, %s](%d),\n", + fmt.Fprintf(w, "\t%s: zapv1.At[%s, %s](%d),\n", f.Name, s.GoName, f.Type, f.Offset) } fmt.Fprintf(w, "}\n\n") @@ -244,7 +244,7 @@ func emitNewConstructor(w io.Writer, s Schema, scalar, accessor []Field) { // so the entire build expands at the call site. Scalars and fixed byte // arrays live in the fixed payload; variable-length string/bytes go in // the object tail (the fixed payload holds their 8-byte pointers). -func New%s(%s) (zapv2.View[%s], []byte) { +func New%s(%s) (zapv1.View[%s], []byte) { b := zap.NewBuilder(%s) ob := b.StartObject(Size%s) ob.SetUint8(0, uint8(Kind%s)) @@ -273,7 +273,7 @@ func New%s(%s) (zapv2.View[%s], []byte) { fmt.Fprintf(w, ` rootOff := ob.FinishAsRoot() buf := b.Finish() end := rootOff + Size%s - return zapv2.AsView[%s](zapv2.RawFromSlices(buf, rootOff, end)), buf + return zapv1.AsView[%s](zapv1.RawFromSlices(buf, rootOff, end)), buf } `, s.WireName, s.GoName) @@ -283,22 +283,22 @@ func New%s(%s) (zapv2.View[%s], []byte) { // type-checks a buffer. The body uses v1 primitives so it inlines. func emitWrapFunction(w io.Writer, s Schema) { fmt.Fprintf(w, `// Wrap%s parses a ZAP buffer into a typed -// [zapv2.View[%s]]. Validates the wire frame and the kind -// discriminator at offset 0; returns [*zapv2.SchemaError] on kind +// [zapv1.View[%s]]. Validates the wire frame and the kind +// discriminator at offset 0; returns [*zapv1.SchemaError] on kind // mismatch. // // Hand-rolled fast path: inlines [zap.Parse] (which is itself // inlineable). Zero heap allocs on the happy path; matches v1 // hand-rolled performance. -func Wrap%s(b []byte) (zapv2.View[%s], error) { +func Wrap%s(b []byte) (zapv1.View[%s], error) { msg, err := zap.Parse(b) if err != nil { - return zapv2.View[%s]{}, err + return zapv1.View[%s]{}, err } root := msg.Root() if got := root.Uint8(0); got != uint8(Kind%s) { - return zapv2.View[%s]{}, zapv2.NewSchemaError( - Kind%s, zapv2.KindByte(got), %q) + return zapv1.View[%s]{}, zapv1.NewSchemaError( + Kind%s, zapv1.KindByte(got), %q) } data := msg.Bytes() rootOff := root.Offset() @@ -306,7 +306,7 @@ func Wrap%s(b []byte) (zapv2.View[%s], error) { if end > len(data) { end = len(data) // Read returns zero on OOB; v1 graceful degradation } - return zapv2.AsView[%s](zapv2.RawFromSlices(data, rootOff, end)), nil + return zapv1.AsView[%s](zapv1.RawFromSlices(data, rootOff, end)), nil } `, s.WireName, s.WireName, @@ -335,9 +335,9 @@ func emitAccessorFields(w io.Writer, s Schema, fields []Field) { // // Zero-copy: v1's Object.Text returns a string over a sub-slice of the // underlying buffer. Valid only while the View's buffer is alive. -func %s%s(v zapv2.View[%s]) string { +func %s%s(v zapv1.View[%s]) string { msg := zap.WrapBuffer(v.Bytes()) - obj := msg.RootObjectAt(int(zapv2.RootOff(v))) + obj := msg.RootObjectAt(int(zapv1.RootOff(v))) return obj.Text(Offset%s_%s) } @@ -349,9 +349,9 @@ func %s%s(v zapv2.View[%s]) string { // // Zero-copy: v1's Object.Bytes returns a sub-slice of the underlying // buffer. Valid only while the View's buffer is alive; copy to retain. -func %s%s(v zapv2.View[%s]) []byte { +func %s%s(v zapv1.View[%s]) []byte { msg := zap.WrapBuffer(v.Bytes()) - obj := msg.RootObjectAt(int(zapv2.RootOff(v))) + obj := msg.RootObjectAt(int(zapv1.RootOff(v))) return obj.Bytes(Offset%s_%s) } @@ -366,9 +366,9 @@ func %s%s(v zapv2.View[%s]) []byte { // a sub-slice of the underlying buffer); the returned [%d]byte is a // value copy so the caller's slot owns the bytes after the View's // buffer is freed. -func %s%s(v zapv2.View[%s]) [%d]byte { +func %s%s(v zapv1.View[%s]) [%d]byte { msg := zap.WrapBuffer(v.Bytes()) - obj := msg.RootObjectAt(int(zapv2.RootOff(v))) + obj := msg.RootObjectAt(int(zapv1.RootOff(v))) slice := obj.BytesFixedSlice(Offset%s_%s, %d) var out [%d]byte if len(slice) == %d { @@ -388,7 +388,7 @@ func %s%s(v zapv2.View[%s]) [%d]byte { } // emitRegisterInit writes an init function that registers the schema -// with the [zapv2.DefaultRegistry]. Skipped when [Schema.SkipRegistry] +// with the [zapv1.DefaultRegistry]. Skipped when [Schema.SkipRegistry] // is true, used for schemas whose Kind byte is local to a per-package // (private) registry rather than globally unique. func emitRegisterInit(w io.Writer, s Schema) { @@ -396,7 +396,7 @@ func emitRegisterInit(w io.Writer, s Schema) { return } fmt.Fprintf(w, `func init() { - zapv2.Register[%s](zapv2.DefaultRegistry) + zapv1.Register[%s](zapv1.DefaultRegistry) } `, s.GoName) } diff --git a/v2/codegen/emit_test.go b/v1/codegen/emit_test.go similarity index 90% rename from v2/codegen/emit_test.go rename to v1/codegen/emit_test.go index 203136f..0b7ec9d 100644 --- a/v2/codegen/emit_test.go +++ b/v1/codegen/emit_test.go @@ -8,7 +8,7 @@ import ( "strings" "testing" - "github.com/luxfi/zap/v2/codegen" + "github.com/luxfi/zap/v1/codegen" ) // TestEmit_AdvanceTime: the canary schema emits source that compiles @@ -40,12 +40,12 @@ func TestEmit_AdvanceTime(t *testing.T) { // Load-bearing markers — the things downstream code uses. wants := []string{ "package examples", - "KindAdvanceTimeTx zapv2.KindByte = 0x01", + "KindAdvanceTimeTx zapv1.KindByte = 0x01", "SizeAdvanceTimeTx = 9", "type AdvanceTimeSchema struct{}", "OffsetAdvanceTimeTx_Time = 1", "AdvanceTimeSchemaFields", - "Time zapv2.Field[AdvanceTimeSchema, uint64]", + "Time zapv1.Field[AdvanceTimeSchema, uint64]", "func NewAdvanceTimeTx(time uint64)", "func WrapAdvanceTimeTx(b []byte)", "zap.NewBuilder(zap.HeaderSize + SizeAdvanceTimeTx)", @@ -54,9 +54,9 @@ func TestEmit_AdvanceTime(t *testing.T) { "zap.Parse(b)", "msg.Root()", "root.Uint8(0)", - "zapv2.AsView[AdvanceTimeSchema]", - "zapv2.RawFromSlices", - "zapv2.Register[AdvanceTimeSchema](zapv2.DefaultRegistry)", + "zapv1.AsView[AdvanceTimeSchema]", + "zapv1.RawFromSlices", + "zapv1.Register[AdvanceTimeSchema](zapv1.DefaultRegistry)", } for _, want := range wants { if !strings.Contains(out, want) { @@ -117,9 +117,9 @@ func TestEmit_VarLength(t *testing.T) { "zap.HeaderSize + SizeVarTx + len(name) + len(data)", // buffer estimate "ob.SetText(OffsetVarTx_Name, name)", "ob.SetBytes(OffsetVarTx_Data, data)", - "func VarTxName(v zapv2.View[VarSchema]) string", + "func VarTxName(v zapv1.View[VarSchema]) string", "return obj.Text(OffsetVarTx_Name)", - "func VarTxData(v zapv2.View[VarSchema]) []byte", + "func VarTxData(v zapv1.View[VarSchema]) []byte", "return obj.Bytes(OffsetVarTx_Data)", } for _, want := range wants { @@ -128,7 +128,7 @@ func TestEmit_VarLength(t *testing.T) { } } // Variable fields must NOT appear in the scalar Fields struct. - if strings.Contains(out, "Name zapv2.Field[") || strings.Contains(out, "Data zapv2.Field[") { + if strings.Contains(out, "Name zapv1.Field[") || strings.Contains(out, "Data zapv1.Field[") { t.Errorf("variable fields must not be in the scalar Fields struct") } } @@ -155,14 +155,14 @@ func TestEmit_BytesField(t *testing.T) { } out := buf.String() wants := []string{ - "KindBlockRequest zapv2.KindByte = 0x53", + "KindBlockRequest zapv1.KindByte = 0x53", "SizeBlockRequest = 34", "OffsetBlockRequest_Version = 1", "OffsetBlockRequest_BlockID = 2", // Scalar field in Fields struct - "Version zapv2.Field[BlockReqSchema, uint8]", + "Version zapv1.Field[BlockReqSchema, uint8]", // Byte-array field NOT in Fields struct, instead its own function: - "func BlockRequestBlockID(v zapv2.View[BlockReqSchema]) [32]byte", + "func BlockRequestBlockID(v zapv1.View[BlockReqSchema]) [32]byte", // Constructor takes both scalar and byte-array args "func NewBlockRequest(version uint8, blockID [32]byte)", // Constructor body writes both @@ -246,9 +246,9 @@ func TestEmit_MultiField(t *testing.T) { } out := buf.String() wants := []string{ - "KindBatchTx zapv2.KindByte = 0x21", - "Flag zapv2.Field[BatchSchema, bool]", - "ID zapv2.Field[BatchSchema, uint64]", + "KindBatchTx zapv1.KindByte = 0x21", + "Flag zapv1.Field[BatchSchema, bool]", + "ID zapv1.Field[BatchSchema, uint64]", "OffsetBatchTx_Flag = 1", "OffsetBatchTx_ID = 9", "ob.SetBool(OffsetBatchTx_Flag, flag)", diff --git a/v2/codegen/schema.go b/v1/codegen/schema.go similarity index 87% rename from v2/codegen/schema.go rename to v1/codegen/schema.go index b486f97..f813da7 100644 --- a/v2/codegen/schema.go +++ b/v1/codegen/schema.go @@ -27,10 +27,10 @@ type Schema struct { // ("bytes"), and variable-length tails ("string"/"bytes"). Each // occupies a slot in the fixed payload (variable-length fields hold // an 8-byte tail pointer there). List and nested-object tails are - // not declared here; they use the generic [zapv2.ListAt] machinery. + // not declared here; they use the generic [zapv1.ListAt] machinery. Fields []Field - // SkipRegistry suppresses the emit of `init() { zapv2.Register[S] - // (zapv2.DefaultRegistry) }`. Use for schema families that have a + // SkipRegistry suppresses the emit of `init() { zapv1.Register[S] + // (zapv1.DefaultRegistry) }`. Use for schema families that have a // PRIVATE Kind namespace (the discriminator byte is unique only // within a per-package registry, not globally). Examples: // @@ -40,7 +40,7 @@ type Schema struct { // would panic on duplicate kind byte at init time. // - LP-182 consensus wire: the 0x01..0x0D kind bytes are local to // the consensus-wire registry (`pkg/wire/zap/schemas.go`), not - // the global zapv2.DefaultRegistry shared with P2P/light-client + // the global zapv1.DefaultRegistry shared with P2P/light-client // schemas at 0xD0+/0xF0+. // // Default is false — schemas with globally-unique Kind bytes @@ -52,18 +52,18 @@ type Schema struct { // // Two field kinds are supported: // -// 1. Scalar fields. Type is one of the [zapv2.FieldKind] members +// 1. Scalar fields. Type is one of the [zapv1.FieldKind] members // (bool, int8/16/32/64, uint8/16/32/64, float32/64). The emitted -// code uses a [zapv2.Field][S, T] handle and the standard -// zapv2.Read/Write generic functions. +// code uses a [zapv1.Field][S, T] handle and the standard +// zapv1.Read/Write generic functions. // // 2. Fixed-width byte-array fields. Type is "bytes" where N is a // positive integer (e.g., "bytes20" for NodeID, "bytes32" for // hashes, "bytes16" for session IDs). The emitted code uses the // v1 ObjectBuilder.SetBytesFixed / Object.BytesFixedSlice // accessors and returns the value as a [N]byte. Byte-array fields -// do NOT use the zapv2.Field generic handle because [N]byte is -// not a [zapv2.FieldKind] member; instead they get a typed +// do NOT use the zapv1.Field generic handle because [N]byte is +// not a [zapv1.FieldKind] member; instead they get a typed // accessor function emitted alongside the schema. // // 3. Variable-length tail fields. Type is "string" or "bytes" (no @@ -73,11 +73,11 @@ type Schema struct { // ObjectBuilder.SetText / SetBytes; reads go through a standalone // accessor over v1's Object.Text / Object.Bytes (zero-copy // sub-slice of the buffer). Like byte-array fields, they do NOT use -// the zapv2.Field generic handle (string/[]byte are not FieldKind +// the zapv1.Field generic handle (string/[]byte are not FieldKind // members). // // List and nested-object tail fields are still hand-written (the -// generic [zapv2.ListAt] / out-of-line pointer machinery). +// generic [zapv1.ListAt] / out-of-line pointer machinery). type Field struct { // Name is the Go-visible field name (e.g. "Time"). Emitted into // the schema's Fields struct as `Fields.Name`. @@ -129,5 +129,5 @@ func (f Field) IsVarBytes() bool { return f.Type == "bytes" } // IsVariable reports whether the field is any variable-length tail field // (string or bytes). Variable fields are emitted as standalone accessor // functions (like fixed byte arrays) rather than in the Fields struct, -// because string/[]byte are not zapv2.FieldKind members. +// because string/[]byte are not zapv1.FieldKind members. func (f Field) IsVariable() bool { return f.IsVarString() || f.IsVarBytes() } diff --git a/v2/codegen/schemas/lp-182-consensus.json b/v1/codegen/schemas/lp-182-consensus.json similarity index 100% rename from v2/codegen/schemas/lp-182-consensus.json rename to v1/codegen/schemas/lp-182-consensus.json diff --git a/v2/codegen/schemas/lp-186-vms.json b/v1/codegen/schemas/lp-186-vms.json similarity index 100% rename from v2/codegen/schemas/lp-186-vms.json rename to v1/codegen/schemas/lp-186-vms.json diff --git a/v2/codegen/schemas/lp-201-p2p.json b/v1/codegen/schemas/lp-201-p2p.json similarity index 100% rename from v2/codegen/schemas/lp-201-p2p.json rename to v1/codegen/schemas/lp-201-p2p.json diff --git a/v2/codegen/schemas/lp-208-dag.json b/v1/codegen/schemas/lp-208-dag.json similarity index 100% rename from v2/codegen/schemas/lp-208-dag.json rename to v1/codegen/schemas/lp-208-dag.json diff --git a/v2/codegen/schemas/lp-211-cross-shard.json b/v1/codegen/schemas/lp-211-cross-shard.json similarity index 100% rename from v2/codegen/schemas/lp-211-cross-shard.json rename to v1/codegen/schemas/lp-211-cross-shard.json diff --git a/v2/codegen/schemas/lp-214-light-client.json b/v1/codegen/schemas/lp-214-light-client.json similarity index 100% rename from v2/codegen/schemas/lp-214-light-client.json rename to v1/codegen/schemas/lp-214-light-client.json diff --git a/v2/codegen/schemas/lp-218-rollup.json b/v1/codegen/schemas/lp-218-rollup.json similarity index 100% rename from v2/codegen/schemas/lp-218-rollup.json rename to v1/codegen/schemas/lp-218-rollup.json diff --git a/v2/codegen/testpkg/lc_block_header_request_zap.go b/v1/codegen/testpkg/lc_block_header_request_zap.go similarity index 73% rename from v2/codegen/testpkg/lc_block_header_request_zap.go rename to v1/codegen/testpkg/lc_block_header_request_zap.go index bc40f59..e947997 100644 --- a/v2/codegen/testpkg/lc_block_header_request_zap.go +++ b/v1/codegen/testpkg/lc_block_header_request_zap.go @@ -1,28 +1,28 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. // -// Code generated by github.com/luxfi/zap/v2/codegen — DO NOT EDIT. +// Code generated by github.com/luxfi/zap/v1/codegen — DO NOT EDIT. // Source schema: LightClientBlockHeaderRequest (kind=0x50, size=51). package lcwire import ( "github.com/luxfi/zap" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) // KindLightClientBlockHeaderRequest is the wire discriminator for LightClientBlockHeaderRequest. -const KindLightClientBlockHeaderRequest zapv2.KindByte = 0x50 +const KindLightClientBlockHeaderRequest zapv1.KindByte = 0x50 // SizeLightClientBlockHeaderRequest is the fixed object payload size in bytes. const SizeLightClientBlockHeaderRequest = 51 // LCBlockHeaderReqSchema is the v2 schema marker for LightClientBlockHeaderRequest. Methods are constant- -// returning so concrete-typed [zapv2.Wrap[LCBlockHeaderReqSchema]] calls fold to +// returning so concrete-typed [zapv1.Wrap[LCBlockHeaderReqSchema]] calls fold to // literals at the call site. type LCBlockHeaderReqSchema struct{} -func (LCBlockHeaderReqSchema) Kind() zapv2.KindByte { return KindLightClientBlockHeaderRequest } +func (LCBlockHeaderReqSchema) Kind() zapv1.KindByte { return KindLightClientBlockHeaderRequest } func (LCBlockHeaderReqSchema) Size() int { return SizeLightClientBlockHeaderRequest } func (LCBlockHeaderReqSchema) Name() string { return "LightClientBlockHeaderRequest" } @@ -45,20 +45,20 @@ const OffsetLightClientBlockHeaderRequest_CertMinTier = 46 const OffsetLightClientBlockHeaderRequest_RequestID = 47 // LCBlockHeaderReqSchemaFields is the namespace of every scalar field accessor for LightClientBlockHeaderRequest. -// Use with [zapv2.Read] / [zapv2.Write] for type-safe access. +// Use with [zapv1.Read] / [zapv1.Write] for type-safe access. // Byte-array fields are emitted as standalone functions, see below. var LCBlockHeaderReqSchemaFields = struct { - Version zapv2.Field[LCBlockHeaderReqSchema, uint8] - ChainID zapv2.Field[LCBlockHeaderReqSchema, uint32] - BlockHeight zapv2.Field[LCBlockHeaderReqSchema, uint64] - CertMinTier zapv2.Field[LCBlockHeaderReqSchema, uint8] - RequestID zapv2.Field[LCBlockHeaderReqSchema, uint32] + Version zapv1.Field[LCBlockHeaderReqSchema, uint8] + ChainID zapv1.Field[LCBlockHeaderReqSchema, uint32] + BlockHeight zapv1.Field[LCBlockHeaderReqSchema, uint64] + CertMinTier zapv1.Field[LCBlockHeaderReqSchema, uint8] + RequestID zapv1.Field[LCBlockHeaderReqSchema, uint32] }{ - Version: zapv2.At[LCBlockHeaderReqSchema, uint8](1), - ChainID: zapv2.At[LCBlockHeaderReqSchema, uint32](2), - BlockHeight: zapv2.At[LCBlockHeaderReqSchema, uint64](6), - CertMinTier: zapv2.At[LCBlockHeaderReqSchema, uint8](46), - RequestID: zapv2.At[LCBlockHeaderReqSchema, uint32](47), + Version: zapv1.At[LCBlockHeaderReqSchema, uint8](1), + ChainID: zapv1.At[LCBlockHeaderReqSchema, uint32](2), + BlockHeight: zapv1.At[LCBlockHeaderReqSchema, uint64](6), + CertMinTier: zapv1.At[LCBlockHeaderReqSchema, uint8](46), + RequestID: zapv1.At[LCBlockHeaderReqSchema, uint32](47), } // NewLightClientBlockHeaderRequest builds a fresh LightClientBlockHeaderRequest in a ZAP buffer. @@ -67,7 +67,7 @@ var LCBlockHeaderReqSchemaFields = struct { // [*Builder.StartObject], [*ObjectBuilder.Set*], [*Builder.Finish]) // so the entire build expands at the call site. Result: 1 heap // alloc (the buffer), zero overhead vs v1. -func NewLightClientBlockHeaderRequest(version uint8, chainID uint32, blockHeight uint64, certMinTier uint8, requestID uint32, blockContentHash [32]byte) (zapv2.View[LCBlockHeaderReqSchema], []byte) { +func NewLightClientBlockHeaderRequest(version uint8, chainID uint32, blockHeight uint64, certMinTier uint8, requestID uint32, blockContentHash [32]byte) (zapv1.View[LCBlockHeaderReqSchema], []byte) { b := zap.NewBuilder(zap.HeaderSize + SizeLightClientBlockHeaderRequest) ob := b.StartObject(SizeLightClientBlockHeaderRequest) ob.SetUint8(0, uint8(KindLightClientBlockHeaderRequest)) @@ -80,26 +80,26 @@ func NewLightClientBlockHeaderRequest(version uint8, chainID uint32, blockHeight rootOff := ob.FinishAsRoot() buf := b.Finish() end := rootOff + SizeLightClientBlockHeaderRequest - return zapv2.AsView[LCBlockHeaderReqSchema](zapv2.RawFromSlices(buf, rootOff, end)), buf + return zapv1.AsView[LCBlockHeaderReqSchema](zapv1.RawFromSlices(buf, rootOff, end)), buf } // WrapLightClientBlockHeaderRequest parses a ZAP buffer into a typed -// [zapv2.View[LightClientBlockHeaderRequest]]. Validates the wire frame and the kind -// discriminator at offset 0; returns [*zapv2.SchemaError] on kind +// [zapv1.View[LightClientBlockHeaderRequest]]. Validates the wire frame and the kind +// discriminator at offset 0; returns [*zapv1.SchemaError] on kind // mismatch. // // Hand-rolled fast path: inlines [zap.Parse] (which is itself // inlineable). Zero heap allocs on the happy path; matches v1 // hand-rolled performance. -func WrapLightClientBlockHeaderRequest(b []byte) (zapv2.View[LCBlockHeaderReqSchema], error) { +func WrapLightClientBlockHeaderRequest(b []byte) (zapv1.View[LCBlockHeaderReqSchema], error) { msg, err := zap.Parse(b) if err != nil { - return zapv2.View[LCBlockHeaderReqSchema]{}, err + return zapv1.View[LCBlockHeaderReqSchema]{}, err } root := msg.Root() if got := root.Uint8(0); got != uint8(KindLightClientBlockHeaderRequest) { - return zapv2.View[LCBlockHeaderReqSchema]{}, zapv2.NewSchemaError( - KindLightClientBlockHeaderRequest, zapv2.KindByte(got), "LightClientBlockHeaderRequest") + return zapv1.View[LCBlockHeaderReqSchema]{}, zapv1.NewSchemaError( + KindLightClientBlockHeaderRequest, zapv1.KindByte(got), "LightClientBlockHeaderRequest") } data := msg.Bytes() rootOff := root.Offset() @@ -107,7 +107,7 @@ func WrapLightClientBlockHeaderRequest(b []byte) (zapv2.View[LCBlockHeaderReqSch if end > len(data) { end = len(data) // Read returns zero on OOB; v1 graceful degradation } - return zapv2.AsView[LCBlockHeaderReqSchema](zapv2.RawFromSlices(data, rootOff, end)), nil + return zapv1.AsView[LCBlockHeaderReqSchema](zapv1.RawFromSlices(data, rootOff, end)), nil } // LightClientBlockHeaderRequestBlockContentHash reads the 32-byte inline BlockContentHash field of LightClientBlockHeaderRequest. @@ -116,9 +116,9 @@ func WrapLightClientBlockHeaderRequest(b []byte) (zapv2.View[LCBlockHeaderReqSch // a sub-slice of the underlying buffer); the returned [32]byte is a // value copy so the caller's slot owns the bytes after the View's // buffer is freed. -func LightClientBlockHeaderRequestBlockContentHash(v zapv2.View[LCBlockHeaderReqSchema]) [32]byte { +func LightClientBlockHeaderRequestBlockContentHash(v zapv1.View[LCBlockHeaderReqSchema]) [32]byte { msg := zap.WrapBuffer(v.Bytes()) - obj := msg.RootObjectAt(int(zapv2.RootOff(v))) + obj := msg.RootObjectAt(int(zapv1.RootOff(v))) slice := obj.BytesFixedSlice(OffsetLightClientBlockHeaderRequest_BlockContentHash, 32) var out [32]byte if len(slice) == 32 { @@ -128,5 +128,5 @@ func LightClientBlockHeaderRequestBlockContentHash(v zapv2.View[LCBlockHeaderReq } func init() { - zapv2.Register[LCBlockHeaderReqSchema](zapv2.DefaultRegistry) + zapv1.Register[LCBlockHeaderReqSchema](zapv1.DefaultRegistry) } diff --git a/v2/codegen/testpkg/lp182_consensuswire/bench_test.go b/v1/codegen/testpkg/lp182_consensuswire/bench_test.go similarity index 94% rename from v2/codegen/testpkg/lp182_consensuswire/bench_test.go rename to v1/codegen/testpkg/lp182_consensuswire/bench_test.go index e250248..1502a37 100644 --- a/v2/codegen/testpkg/lp182_consensuswire/bench_test.go +++ b/v1/codegen/testpkg/lp182_consensuswire/bench_test.go @@ -6,7 +6,7 @@ package consensuswire import ( "testing" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) // BenchmarkQuasarCert_Build measures the codegen-emitted NewQuasarCert @@ -61,7 +61,7 @@ func BenchmarkQuasarCert_RoundTrip(b *testing.B) { if err != nil { b.Fatalf("Wrap: %v", err) } - _ = zapv2.Read(view, QuasarCertSchemaFields.Epoch) + _ = zapv1.Read(view, QuasarCertSchemaFields.Epoch) } } @@ -81,6 +81,6 @@ func BenchmarkQuasarCert_Read(b *testing.B) { b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - _ = zapv2.Read(view, QuasarCertSchemaFields.Epoch) + _ = zapv1.Read(view, QuasarCertSchemaFields.Epoch) } } diff --git a/v2/codegen/testpkg/lp182_consensuswire/quasar_cert_zap.go b/v1/codegen/testpkg/lp182_consensuswire/quasar_cert_zap.go similarity index 66% rename from v2/codegen/testpkg/lp182_consensuswire/quasar_cert_zap.go rename to v1/codegen/testpkg/lp182_consensuswire/quasar_cert_zap.go index f127f2f..ea2a9a0 100644 --- a/v2/codegen/testpkg/lp182_consensuswire/quasar_cert_zap.go +++ b/v1/codegen/testpkg/lp182_consensuswire/quasar_cert_zap.go @@ -1,28 +1,28 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. // -// Code generated by github.com/luxfi/zap/v2/codegen — DO NOT EDIT. +// Code generated by github.com/luxfi/zap/v1/codegen — DO NOT EDIT. // Source schema: QuasarCert (kind=0x01, size=72). package consensuswire import ( "github.com/luxfi/zap" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) // KindQuasarCert is the wire discriminator for QuasarCert. -const KindQuasarCert zapv2.KindByte = 0x01 +const KindQuasarCert zapv1.KindByte = 0x01 // SizeQuasarCert is the fixed object payload size in bytes. const SizeQuasarCert = 72 // QuasarCertSchema is the v2 schema marker for QuasarCert. Methods are constant- -// returning so concrete-typed [zapv2.Wrap[QuasarCertSchema]] calls fold to +// returning so concrete-typed [zapv1.Wrap[QuasarCertSchema]] calls fold to // literals at the call site. type QuasarCertSchema struct{} -func (QuasarCertSchema) Kind() zapv2.KindByte { return KindQuasarCert } +func (QuasarCertSchema) Kind() zapv1.KindByte { return KindQuasarCert } func (QuasarCertSchema) Size() int { return SizeQuasarCert } func (QuasarCertSchema) Name() string { return "QuasarCert" } @@ -66,36 +66,36 @@ const OffsetQuasarCert_MLDSARollupOff = 64 const OffsetQuasarCert_MLDSARollupLen = 68 // QuasarCertSchemaFields is the namespace of every scalar field accessor for QuasarCert. -// Use with [zapv2.Read] / [zapv2.Write] for type-safe access. +// Use with [zapv1.Read] / [zapv1.Write] for type-safe access. // Byte-array fields are emitted as standalone functions, see below. var QuasarCertSchemaFields = struct { - Epoch zapv2.Field[QuasarCertSchema, uint64] - FinalityUnixNano zapv2.Field[QuasarCertSchema, int64] - Validators zapv2.Field[QuasarCertSchema, uint32] - BLSOff zapv2.Field[QuasarCertSchema, uint32] - BLSLen zapv2.Field[QuasarCertSchema, uint32] - CoronaOff zapv2.Field[QuasarCertSchema, uint32] - CoronaLen zapv2.Field[QuasarCertSchema, uint32] - PulsarOff zapv2.Field[QuasarCertSchema, uint32] - PulsarLen zapv2.Field[QuasarCertSchema, uint32] - MagnetarOff zapv2.Field[QuasarCertSchema, uint32] - MagnetarLen zapv2.Field[QuasarCertSchema, uint32] - MLDSARollupOff zapv2.Field[QuasarCertSchema, uint32] - MLDSARollupLen zapv2.Field[QuasarCertSchema, uint32] + Epoch zapv1.Field[QuasarCertSchema, uint64] + FinalityUnixNano zapv1.Field[QuasarCertSchema, int64] + Validators zapv1.Field[QuasarCertSchema, uint32] + BLSOff zapv1.Field[QuasarCertSchema, uint32] + BLSLen zapv1.Field[QuasarCertSchema, uint32] + CoronaOff zapv1.Field[QuasarCertSchema, uint32] + CoronaLen zapv1.Field[QuasarCertSchema, uint32] + PulsarOff zapv1.Field[QuasarCertSchema, uint32] + PulsarLen zapv1.Field[QuasarCertSchema, uint32] + MagnetarOff zapv1.Field[QuasarCertSchema, uint32] + MagnetarLen zapv1.Field[QuasarCertSchema, uint32] + MLDSARollupOff zapv1.Field[QuasarCertSchema, uint32] + MLDSARollupLen zapv1.Field[QuasarCertSchema, uint32] }{ - Epoch: zapv2.At[QuasarCertSchema, uint64](8), - FinalityUnixNano: zapv2.At[QuasarCertSchema, int64](16), - Validators: zapv2.At[QuasarCertSchema, uint32](24), - BLSOff: zapv2.At[QuasarCertSchema, uint32](32), - BLSLen: zapv2.At[QuasarCertSchema, uint32](36), - CoronaOff: zapv2.At[QuasarCertSchema, uint32](40), - CoronaLen: zapv2.At[QuasarCertSchema, uint32](44), - PulsarOff: zapv2.At[QuasarCertSchema, uint32](48), - PulsarLen: zapv2.At[QuasarCertSchema, uint32](52), - MagnetarOff: zapv2.At[QuasarCertSchema, uint32](56), - MagnetarLen: zapv2.At[QuasarCertSchema, uint32](60), - MLDSARollupOff: zapv2.At[QuasarCertSchema, uint32](64), - MLDSARollupLen: zapv2.At[QuasarCertSchema, uint32](68), + Epoch: zapv1.At[QuasarCertSchema, uint64](8), + FinalityUnixNano: zapv1.At[QuasarCertSchema, int64](16), + Validators: zapv1.At[QuasarCertSchema, uint32](24), + BLSOff: zapv1.At[QuasarCertSchema, uint32](32), + BLSLen: zapv1.At[QuasarCertSchema, uint32](36), + CoronaOff: zapv1.At[QuasarCertSchema, uint32](40), + CoronaLen: zapv1.At[QuasarCertSchema, uint32](44), + PulsarOff: zapv1.At[QuasarCertSchema, uint32](48), + PulsarLen: zapv1.At[QuasarCertSchema, uint32](52), + MagnetarOff: zapv1.At[QuasarCertSchema, uint32](56), + MagnetarLen: zapv1.At[QuasarCertSchema, uint32](60), + MLDSARollupOff: zapv1.At[QuasarCertSchema, uint32](64), + MLDSARollupLen: zapv1.At[QuasarCertSchema, uint32](68), } // NewQuasarCert builds a fresh QuasarCert in a ZAP buffer. @@ -104,7 +104,7 @@ var QuasarCertSchemaFields = struct { // [*Builder.StartObject], [*ObjectBuilder.Set*], [*Builder.Finish]) // so the entire build expands at the call site. Result: 1 heap // alloc (the buffer), zero overhead vs v1. -func NewQuasarCert(epoch uint64, finalityUnixNano int64, validators uint32, bLSOff uint32, bLSLen uint32, coronaOff uint32, coronaLen uint32, pulsarOff uint32, pulsarLen uint32, magnetarOff uint32, magnetarLen uint32, mLDSARollupOff uint32, mLDSARollupLen uint32) (zapv2.View[QuasarCertSchema], []byte) { +func NewQuasarCert(epoch uint64, finalityUnixNano int64, validators uint32, bLSOff uint32, bLSLen uint32, coronaOff uint32, coronaLen uint32, pulsarOff uint32, pulsarLen uint32, magnetarOff uint32, magnetarLen uint32, mLDSARollupOff uint32, mLDSARollupLen uint32) (zapv1.View[QuasarCertSchema], []byte) { b := zap.NewBuilder(zap.HeaderSize + SizeQuasarCert) ob := b.StartObject(SizeQuasarCert) ob.SetUint8(0, uint8(KindQuasarCert)) @@ -124,26 +124,26 @@ func NewQuasarCert(epoch uint64, finalityUnixNano int64, validators uint32, bLSO rootOff := ob.FinishAsRoot() buf := b.Finish() end := rootOff + SizeQuasarCert - return zapv2.AsView[QuasarCertSchema](zapv2.RawFromSlices(buf, rootOff, end)), buf + return zapv1.AsView[QuasarCertSchema](zapv1.RawFromSlices(buf, rootOff, end)), buf } // WrapQuasarCert parses a ZAP buffer into a typed -// [zapv2.View[QuasarCert]]. Validates the wire frame and the kind -// discriminator at offset 0; returns [*zapv2.SchemaError] on kind +// [zapv1.View[QuasarCert]]. Validates the wire frame and the kind +// discriminator at offset 0; returns [*zapv1.SchemaError] on kind // mismatch. // // Hand-rolled fast path: inlines [zap.Parse] (which is itself // inlineable). Zero heap allocs on the happy path; matches v1 // hand-rolled performance. -func WrapQuasarCert(b []byte) (zapv2.View[QuasarCertSchema], error) { +func WrapQuasarCert(b []byte) (zapv1.View[QuasarCertSchema], error) { msg, err := zap.Parse(b) if err != nil { - return zapv2.View[QuasarCertSchema]{}, err + return zapv1.View[QuasarCertSchema]{}, err } root := msg.Root() if got := root.Uint8(0); got != uint8(KindQuasarCert) { - return zapv2.View[QuasarCertSchema]{}, zapv2.NewSchemaError( - KindQuasarCert, zapv2.KindByte(got), "QuasarCert") + return zapv1.View[QuasarCertSchema]{}, zapv1.NewSchemaError( + KindQuasarCert, zapv1.KindByte(got), "QuasarCert") } data := msg.Bytes() rootOff := root.Offset() @@ -151,6 +151,6 @@ func WrapQuasarCert(b []byte) (zapv2.View[QuasarCertSchema], error) { if end > len(data) { end = len(data) // Read returns zero on OOB; v1 graceful degradation } - return zapv2.AsView[QuasarCertSchema](zapv2.RawFromSlices(data, rootOff, end)), nil + return zapv1.AsView[QuasarCertSchema](zapv1.RawFromSlices(data, rootOff, end)), nil } diff --git a/v2/codegen/testpkg/lp182_consensuswire/roundtrip_test.go b/v1/codegen/testpkg/lp182_consensuswire/roundtrip_test.go similarity index 87% rename from v2/codegen/testpkg/lp182_consensuswire/roundtrip_test.go rename to v1/codegen/testpkg/lp182_consensuswire/roundtrip_test.go index f4e5c45..2453219 100644 --- a/v2/codegen/testpkg/lp182_consensuswire/roundtrip_test.go +++ b/v1/codegen/testpkg/lp182_consensuswire/roundtrip_test.go @@ -21,7 +21,7 @@ import ( "encoding/binary" "testing" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) // TestQuasarCert_RoundTrip: build with distinctive values for every @@ -72,25 +72,25 @@ func TestQuasarCert_RoundTrip(t *testing.T) { t.Fatalf("WrapQuasarCert: %v", err) } - if got := zapv2.Read(view2, QuasarCertSchemaFields.Epoch); got != want.Epoch { + if got := zapv1.Read(view2, QuasarCertSchemaFields.Epoch); got != want.Epoch { t.Errorf("Epoch = %#x; want %#x", got, want.Epoch) } - if got := zapv2.Read(view2, QuasarCertSchemaFields.FinalityUnixNano); got != want.FinalityUnixNano { + if got := zapv1.Read(view2, QuasarCertSchemaFields.FinalityUnixNano); got != want.FinalityUnixNano { t.Errorf("FinalityUnixNano = %d; want %d", got, want.FinalityUnixNano) } - if got := zapv2.Read(view2, QuasarCertSchemaFields.Validators); got != want.Validators { + if got := zapv1.Read(view2, QuasarCertSchemaFields.Validators); got != want.Validators { t.Errorf("Validators = %d; want %d", got, want.Validators) } - if got := zapv2.Read(view2, QuasarCertSchemaFields.BLSOff); got != want.BLSOff { + if got := zapv1.Read(view2, QuasarCertSchemaFields.BLSOff); got != want.BLSOff { t.Errorf("BLSOff = %#x; want %#x", got, want.BLSOff) } - if got := zapv2.Read(view2, QuasarCertSchemaFields.BLSLen); got != want.BLSLen { + if got := zapv1.Read(view2, QuasarCertSchemaFields.BLSLen); got != want.BLSLen { t.Errorf("BLSLen = %d; want %d", got, want.BLSLen) } - if got := zapv2.Read(view2, QuasarCertSchemaFields.PulsarLen); got != want.PulsarLen { + if got := zapv1.Read(view2, QuasarCertSchemaFields.PulsarLen); got != want.PulsarLen { t.Errorf("PulsarLen = %d; want %d", got, want.PulsarLen) } - if got := zapv2.Read(view2, QuasarCertSchemaFields.MLDSARollupOff); got != want.MLDSARollupOff { + if got := zapv1.Read(view2, QuasarCertSchemaFields.MLDSARollupOff); got != want.MLDSARollupOff { t.Errorf("MLDSARollupOff = %#x; want %#x", got, want.MLDSARollupOff) } } @@ -114,8 +114,8 @@ func TestQuasarCert_KindMismatch(t *testing.T) { if err == nil { t.Fatal("expected SchemaError on kind mismatch") } - if _, ok := err.(*zapv2.SchemaError); !ok { - t.Errorf("expected *zapv2.SchemaError, got %T: %v", err, err) + if _, ok := err.(*zapv1.SchemaError); !ok { + t.Errorf("expected *zapv1.SchemaError, got %T: %v", err, err) } } @@ -141,11 +141,11 @@ func TestQuasarCert_Metadata(t *testing.T) { // TestQuasarCert_NotRegistered: the LP-182 consensus-wire schemas // explicitly skip global registration because their 0x01..0x0D kind // bytes are LOCAL to the consensus wire registry, not the global -// zapv2.DefaultRegistry that hosts LP-201 (0xD0+) and LP-214 (0xF0+). +// zapv1.DefaultRegistry that hosts LP-201 (0xD0+) and LP-214 (0xF0+). // Verify init() did NOT register QuasarCert globally. func TestQuasarCert_NotRegistered(t *testing.T) { t.Parallel() - if entry, ok := zapv2.DefaultRegistry.Lookup(KindQuasarCert); ok { + if entry, ok := zapv1.DefaultRegistry.Lookup(KindQuasarCert); ok { // 0x01 might be claimed by some unrelated schema in the same test // binary. Only fail if the entry's name is ours — that would mean // the codegen ignored skip_registry. diff --git a/v2/codegen/testpkg/lp186_zkvmwire/bench_test.go b/v1/codegen/testpkg/lp186_zkvmwire/bench_test.go similarity index 94% rename from v2/codegen/testpkg/lp186_zkvmwire/bench_test.go rename to v1/codegen/testpkg/lp186_zkvmwire/bench_test.go index 2265610..2d2738d 100644 --- a/v2/codegen/testpkg/lp186_zkvmwire/bench_test.go +++ b/v1/codegen/testpkg/lp186_zkvmwire/bench_test.go @@ -6,7 +6,7 @@ package zkvmwire import ( "testing" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) var benchTxID = [32]byte{ @@ -66,7 +66,7 @@ func BenchmarkZKVMUTXO_RoundTrip(b *testing.B) { if err != nil { b.Fatalf("Wrap: %v", err) } - _ = zapv2.Read(view, ZKVMUTXOSchemaFields.Height) + _ = zapv1.Read(view, ZKVMUTXOSchemaFields.Height) } } @@ -85,7 +85,7 @@ func BenchmarkZKVMUTXO_Read(b *testing.B) { b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - _ = zapv2.Read(view, ZKVMUTXOSchemaFields.Height) + _ = zapv1.Read(view, ZKVMUTXOSchemaFields.Height) } } diff --git a/v2/codegen/testpkg/lp186_zkvmwire/roundtrip_test.go b/v1/codegen/testpkg/lp186_zkvmwire/roundtrip_test.go similarity index 89% rename from v2/codegen/testpkg/lp186_zkvmwire/roundtrip_test.go rename to v1/codegen/testpkg/lp186_zkvmwire/roundtrip_test.go index a7fc6d7..8822719 100644 --- a/v2/codegen/testpkg/lp186_zkvmwire/roundtrip_test.go +++ b/v1/codegen/testpkg/lp186_zkvmwire/roundtrip_test.go @@ -21,7 +21,7 @@ import ( "encoding/binary" "testing" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) // TestZKVMUTXO_RoundTrip: build with distinctive values for every @@ -71,22 +71,22 @@ func TestZKVMUTXO_RoundTrip(t *testing.T) { t.Fatalf("WrapZKVMUTXO: %v", err) } - if got := zapv2.Read(view2, ZKVMUTXOSchemaFields.OutputIndex); got != want.OutputIndex { + if got := zapv1.Read(view2, ZKVMUTXOSchemaFields.OutputIndex); got != want.OutputIndex { t.Errorf("OutputIndex = %#x; want %#x", got, want.OutputIndex) } - if got := zapv2.Read(view2, ZKVMUTXOSchemaFields.Height); got != want.Height { + if got := zapv1.Read(view2, ZKVMUTXOSchemaFields.Height); got != want.Height { t.Errorf("Height = %#x; want %#x", got, want.Height) } - if got := zapv2.Read(view2, ZKVMUTXOSchemaFields.CommitmentOff); got != want.CommitmentOff { + if got := zapv1.Read(view2, ZKVMUTXOSchemaFields.CommitmentOff); got != want.CommitmentOff { t.Errorf("CommitmentOff = %#x; want %#x", got, want.CommitmentOff) } - if got := zapv2.Read(view2, ZKVMUTXOSchemaFields.CommitmentLen); got != want.CommitmentLen { + if got := zapv1.Read(view2, ZKVMUTXOSchemaFields.CommitmentLen); got != want.CommitmentLen { t.Errorf("CommitmentLen = %d; want %d", got, want.CommitmentLen) } - if got := zapv2.Read(view2, ZKVMUTXOSchemaFields.CiphertextLen); got != want.CiphertextLen { + if got := zapv1.Read(view2, ZKVMUTXOSchemaFields.CiphertextLen); got != want.CiphertextLen { t.Errorf("CiphertextLen = %d; want %d", got, want.CiphertextLen) } - if got := zapv2.Read(view2, ZKVMUTXOSchemaFields.EphemeralPKOff); got != want.EphemeralPKOff { + if got := zapv1.Read(view2, ZKVMUTXOSchemaFields.EphemeralPKOff); got != want.EphemeralPKOff { t.Errorf("EphemeralPKOff = %#x; want %#x", got, want.EphemeralPKOff) } @@ -116,8 +116,8 @@ func TestZKVMUTXO_KindMismatch(t *testing.T) { if err == nil { t.Fatal("expected SchemaError on kind mismatch") } - if _, ok := err.(*zapv2.SchemaError); !ok { - t.Errorf("expected *zapv2.SchemaError, got %T: %v", err, err) + if _, ok := err.(*zapv1.SchemaError); !ok { + t.Errorf("expected *zapv1.SchemaError, got %T: %v", err, err) } } @@ -147,7 +147,7 @@ func TestZKVMUTXO_Metadata(t *testing.T) { // NOT register ZKVMUTXO globally. func TestZKVMUTXO_NotRegistered(t *testing.T) { t.Parallel() - if entry, ok := zapv2.DefaultRegistry.Lookup(KindZKVMUTXO); ok { + if entry, ok := zapv1.DefaultRegistry.Lookup(KindZKVMUTXO); ok { if entry.Name == "ZKVMUTXO" { t.Fatalf("ZKVMUTXOSchema was registered in DefaultRegistry "+ "despite skip_registry=true; entry=%+v", entry) diff --git a/v2/codegen/testpkg/lp186_zkvmwire/utxo_zap.go b/v1/codegen/testpkg/lp186_zkvmwire/utxo_zap.go similarity index 69% rename from v2/codegen/testpkg/lp186_zkvmwire/utxo_zap.go rename to v1/codegen/testpkg/lp186_zkvmwire/utxo_zap.go index 0d4914e..fa04b94 100644 --- a/v2/codegen/testpkg/lp186_zkvmwire/utxo_zap.go +++ b/v1/codegen/testpkg/lp186_zkvmwire/utxo_zap.go @@ -1,28 +1,28 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. // -// Code generated by github.com/luxfi/zap/v2/codegen — DO NOT EDIT. +// Code generated by github.com/luxfi/zap/v1/codegen — DO NOT EDIT. // Source schema: ZKVMUTXO (kind=0x03, size=72). package zkvmwire import ( "github.com/luxfi/zap" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) // KindZKVMUTXO is the wire discriminator for ZKVMUTXO. -const KindZKVMUTXO zapv2.KindByte = 0x03 +const KindZKVMUTXO zapv1.KindByte = 0x03 // SizeZKVMUTXO is the fixed object payload size in bytes. const SizeZKVMUTXO = 72 // ZKVMUTXOSchema is the v2 schema marker for ZKVMUTXO. Methods are constant- -// returning so concrete-typed [zapv2.Wrap[ZKVMUTXOSchema]] calls fold to +// returning so concrete-typed [zapv1.Wrap[ZKVMUTXOSchema]] calls fold to // literals at the call site. type ZKVMUTXOSchema struct{} -func (ZKVMUTXOSchema) Kind() zapv2.KindByte { return KindZKVMUTXO } +func (ZKVMUTXOSchema) Kind() zapv1.KindByte { return KindZKVMUTXO } func (ZKVMUTXOSchema) Size() int { return SizeZKVMUTXO } func (ZKVMUTXOSchema) Name() string { return "ZKVMUTXO" } @@ -54,26 +54,26 @@ const OffsetZKVMUTXO_EphemeralPKOff = 64 const OffsetZKVMUTXO_EphemeralPKLen = 68 // ZKVMUTXOSchemaFields is the namespace of every scalar field accessor for ZKVMUTXO. -// Use with [zapv2.Read] / [zapv2.Write] for type-safe access. +// Use with [zapv1.Read] / [zapv1.Write] for type-safe access. // Byte-array fields are emitted as standalone functions, see below. var ZKVMUTXOSchemaFields = struct { - OutputIndex zapv2.Field[ZKVMUTXOSchema, uint32] - Height zapv2.Field[ZKVMUTXOSchema, uint64] - CommitmentOff zapv2.Field[ZKVMUTXOSchema, uint32] - CommitmentLen zapv2.Field[ZKVMUTXOSchema, uint32] - CiphertextOff zapv2.Field[ZKVMUTXOSchema, uint32] - CiphertextLen zapv2.Field[ZKVMUTXOSchema, uint32] - EphemeralPKOff zapv2.Field[ZKVMUTXOSchema, uint32] - EphemeralPKLen zapv2.Field[ZKVMUTXOSchema, uint32] + OutputIndex zapv1.Field[ZKVMUTXOSchema, uint32] + Height zapv1.Field[ZKVMUTXOSchema, uint64] + CommitmentOff zapv1.Field[ZKVMUTXOSchema, uint32] + CommitmentLen zapv1.Field[ZKVMUTXOSchema, uint32] + CiphertextOff zapv1.Field[ZKVMUTXOSchema, uint32] + CiphertextLen zapv1.Field[ZKVMUTXOSchema, uint32] + EphemeralPKOff zapv1.Field[ZKVMUTXOSchema, uint32] + EphemeralPKLen zapv1.Field[ZKVMUTXOSchema, uint32] }{ - OutputIndex: zapv2.At[ZKVMUTXOSchema, uint32](4), - Height: zapv2.At[ZKVMUTXOSchema, uint64](8), - CommitmentOff: zapv2.At[ZKVMUTXOSchema, uint32](48), - CommitmentLen: zapv2.At[ZKVMUTXOSchema, uint32](52), - CiphertextOff: zapv2.At[ZKVMUTXOSchema, uint32](56), - CiphertextLen: zapv2.At[ZKVMUTXOSchema, uint32](60), - EphemeralPKOff: zapv2.At[ZKVMUTXOSchema, uint32](64), - EphemeralPKLen: zapv2.At[ZKVMUTXOSchema, uint32](68), + OutputIndex: zapv1.At[ZKVMUTXOSchema, uint32](4), + Height: zapv1.At[ZKVMUTXOSchema, uint64](8), + CommitmentOff: zapv1.At[ZKVMUTXOSchema, uint32](48), + CommitmentLen: zapv1.At[ZKVMUTXOSchema, uint32](52), + CiphertextOff: zapv1.At[ZKVMUTXOSchema, uint32](56), + CiphertextLen: zapv1.At[ZKVMUTXOSchema, uint32](60), + EphemeralPKOff: zapv1.At[ZKVMUTXOSchema, uint32](64), + EphemeralPKLen: zapv1.At[ZKVMUTXOSchema, uint32](68), } // NewZKVMUTXO builds a fresh ZKVMUTXO in a ZAP buffer. @@ -82,7 +82,7 @@ var ZKVMUTXOSchemaFields = struct { // [*Builder.StartObject], [*ObjectBuilder.Set*], [*Builder.Finish]) // so the entire build expands at the call site. Result: 1 heap // alloc (the buffer), zero overhead vs v1. -func NewZKVMUTXO(outputIndex uint32, height uint64, commitmentOff uint32, commitmentLen uint32, ciphertextOff uint32, ciphertextLen uint32, ephemeralPKOff uint32, ephemeralPKLen uint32, txID [32]byte) (zapv2.View[ZKVMUTXOSchema], []byte) { +func NewZKVMUTXO(outputIndex uint32, height uint64, commitmentOff uint32, commitmentLen uint32, ciphertextOff uint32, ciphertextLen uint32, ephemeralPKOff uint32, ephemeralPKLen uint32, txID [32]byte) (zapv1.View[ZKVMUTXOSchema], []byte) { b := zap.NewBuilder(zap.HeaderSize + SizeZKVMUTXO) ob := b.StartObject(SizeZKVMUTXO) ob.SetUint8(0, uint8(KindZKVMUTXO)) @@ -98,26 +98,26 @@ func NewZKVMUTXO(outputIndex uint32, height uint64, commitmentOff uint32, commit rootOff := ob.FinishAsRoot() buf := b.Finish() end := rootOff + SizeZKVMUTXO - return zapv2.AsView[ZKVMUTXOSchema](zapv2.RawFromSlices(buf, rootOff, end)), buf + return zapv1.AsView[ZKVMUTXOSchema](zapv1.RawFromSlices(buf, rootOff, end)), buf } // WrapZKVMUTXO parses a ZAP buffer into a typed -// [zapv2.View[ZKVMUTXO]]. Validates the wire frame and the kind -// discriminator at offset 0; returns [*zapv2.SchemaError] on kind +// [zapv1.View[ZKVMUTXO]]. Validates the wire frame and the kind +// discriminator at offset 0; returns [*zapv1.SchemaError] on kind // mismatch. // // Hand-rolled fast path: inlines [zap.Parse] (which is itself // inlineable). Zero heap allocs on the happy path; matches v1 // hand-rolled performance. -func WrapZKVMUTXO(b []byte) (zapv2.View[ZKVMUTXOSchema], error) { +func WrapZKVMUTXO(b []byte) (zapv1.View[ZKVMUTXOSchema], error) { msg, err := zap.Parse(b) if err != nil { - return zapv2.View[ZKVMUTXOSchema]{}, err + return zapv1.View[ZKVMUTXOSchema]{}, err } root := msg.Root() if got := root.Uint8(0); got != uint8(KindZKVMUTXO) { - return zapv2.View[ZKVMUTXOSchema]{}, zapv2.NewSchemaError( - KindZKVMUTXO, zapv2.KindByte(got), "ZKVMUTXO") + return zapv1.View[ZKVMUTXOSchema]{}, zapv1.NewSchemaError( + KindZKVMUTXO, zapv1.KindByte(got), "ZKVMUTXO") } data := msg.Bytes() rootOff := root.Offset() @@ -125,7 +125,7 @@ func WrapZKVMUTXO(b []byte) (zapv2.View[ZKVMUTXOSchema], error) { if end > len(data) { end = len(data) // Read returns zero on OOB; v1 graceful degradation } - return zapv2.AsView[ZKVMUTXOSchema](zapv2.RawFromSlices(data, rootOff, end)), nil + return zapv1.AsView[ZKVMUTXOSchema](zapv1.RawFromSlices(data, rootOff, end)), nil } // ZKVMUTXOTxID reads the 32-byte inline TxID field of ZKVMUTXO. @@ -134,9 +134,9 @@ func WrapZKVMUTXO(b []byte) (zapv2.View[ZKVMUTXOSchema], error) { // a sub-slice of the underlying buffer); the returned [32]byte is a // value copy so the caller's slot owns the bytes after the View's // buffer is freed. -func ZKVMUTXOTxID(v zapv2.View[ZKVMUTXOSchema]) [32]byte { +func ZKVMUTXOTxID(v zapv1.View[ZKVMUTXOSchema]) [32]byte { msg := zap.WrapBuffer(v.Bytes()) - obj := msg.RootObjectAt(int(zapv2.RootOff(v))) + obj := msg.RootObjectAt(int(zapv1.RootOff(v))) slice := obj.BytesFixedSlice(OffsetZKVMUTXO_TxID, 32) var out [32]byte if len(slice) == 32 { diff --git a/v2/codegen/testpkg/roundtrip_test.go b/v1/codegen/testpkg/roundtrip_test.go similarity index 90% rename from v2/codegen/testpkg/roundtrip_test.go rename to v1/codegen/testpkg/roundtrip_test.go index 227ede6..9f7aca9 100644 --- a/v2/codegen/testpkg/roundtrip_test.go +++ b/v1/codegen/testpkg/roundtrip_test.go @@ -13,7 +13,7 @@ // equality with what was set. This catches regressions in: // - Constructor field-write order vs offsets // - Wrap kind-discriminator check -// - Scalar field accessors via zapv2.Read +// - Scalar field accessors via zapv1.Read // - Byte-array field accessor (zero-copy slice + value-copy) // // If this test passes, the codegen's emitted files are functionally @@ -27,7 +27,7 @@ import ( "encoding/binary" "testing" - zapv2 "github.com/luxfi/zap/v2" + zapv1 "github.com/luxfi/zap/v1" ) // TestRoundTrip_ScalarsAndBytes: build with a set of distinctive @@ -121,8 +121,8 @@ func TestWrap_KindMismatch(t *testing.T) { t.Fatal("expected SchemaError on kind mismatch") } // Verify it's the typed error, not just any error. - if _, ok := err.(*zapv2.SchemaError); !ok { - t.Errorf("expected *zapv2.SchemaError, got %T: %v", err, err) + if _, ok := err.(*zapv1.SchemaError); !ok { + t.Errorf("expected *zapv1.SchemaError, got %T: %v", err, err) } } @@ -146,7 +146,7 @@ func TestSchemaMetadata(t *testing.T) { // registered the schema with the package-level Registry. func TestSchemaRegistered(t *testing.T) { t.Parallel() - entry, ok := zapv2.DefaultRegistry.Lookup(KindLightClientBlockHeaderRequest) + entry, ok := zapv1.DefaultRegistry.Lookup(KindLightClientBlockHeaderRequest) if !ok { t.Fatal("LCBlockHeaderReqSchema not registered in DefaultRegistry") } @@ -157,23 +157,23 @@ func TestSchemaRegistered(t *testing.T) { } // checkScalarFields is the shared assertion helper for TestRoundTrip_*. -func checkScalarFields(t *testing.T, v zapv2.View[LCBlockHeaderReqSchema], +func checkScalarFields(t *testing.T, v zapv1.View[LCBlockHeaderReqSchema], wantVersion uint8, wantChainID uint32, wantBlockHeight uint64, wantCertMinTier uint8, wantRequestID uint32) { t.Helper() - if got := zapv2.Read(v, LCBlockHeaderReqSchemaFields.Version); got != wantVersion { + if got := zapv1.Read(v, LCBlockHeaderReqSchemaFields.Version); got != wantVersion { t.Errorf("Version = %d; want %d", got, wantVersion) } - if got := zapv2.Read(v, LCBlockHeaderReqSchemaFields.ChainID); got != wantChainID { + if got := zapv1.Read(v, LCBlockHeaderReqSchemaFields.ChainID); got != wantChainID { t.Errorf("ChainID = %d; want %d", got, wantChainID) } - if got := zapv2.Read(v, LCBlockHeaderReqSchemaFields.BlockHeight); got != wantBlockHeight { + if got := zapv1.Read(v, LCBlockHeaderReqSchemaFields.BlockHeight); got != wantBlockHeight { t.Errorf("BlockHeight = 0x%x; want 0x%x", got, wantBlockHeight) } - if got := zapv2.Read(v, LCBlockHeaderReqSchemaFields.CertMinTier); got != wantCertMinTier { + if got := zapv1.Read(v, LCBlockHeaderReqSchemaFields.CertMinTier); got != wantCertMinTier { t.Errorf("CertMinTier = %d; want %d", got, wantCertMinTier) } - if got := zapv2.Read(v, LCBlockHeaderReqSchemaFields.RequestID); got != wantRequestID { + if got := zapv1.Read(v, LCBlockHeaderReqSchemaFields.RequestID); got != wantRequestID { t.Errorf("RequestID = %d; want %d", got, wantRequestID) } } diff --git a/v2/compile_fail_test.go b/v1/compile_fail_test.go similarity index 98% rename from v2/compile_fail_test.go rename to v1/compile_fail_test.go index cfb0661..0af40b1 100644 --- a/v2/compile_fail_test.go +++ b/v1/compile_fail_test.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2_test +package zapv1_test import ( "os/exec" diff --git a/v2/doc.go b/v1/doc.go similarity index 96% rename from v2/doc.go rename to v1/doc.go index 3d4a867..4e78d6c 100644 --- a/v2/doc.go +++ b/v1/doc.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -// Package zapv2 is the elegant, generic, idiomatic Go reference +// Package zapv1 is the elegant, generic, idiomatic Go reference // implementation of the ZAP wire format. // // Where the v1 [github.com/luxfi/zap] package exposes a C-shaped API @@ -46,4 +46,4 @@ // // One and only one way to express any of these. No braiding of policy // with primitive, no inheritance, no duplication. -package zapv2 +package zapv1 diff --git a/v2/examples/advance_time_tx.go b/v1/examples/advance_time_tx.go similarity index 77% rename from v2/examples/advance_time_tx.go rename to v1/examples/advance_time_tx.go index b699e4c..5941312 100644 --- a/v2/examples/advance_time_tx.go +++ b/v1/examples/advance_time_tx.go @@ -20,14 +20,14 @@ // v2 shape (declarations only; the generic API does the rest): // // type AdvanceTimeSchema struct{} -// func (AdvanceTimeSchema) Kind() zapv2.KindByte { return 0x14 } +// func (AdvanceTimeSchema) Kind() zapv1.KindByte { return 0x14 } // func (AdvanceTimeSchema) Size() int { return 9 } // func (AdvanceTimeSchema) Name() string { return "AdvanceTimeTx" } // // var AdvanceTimeFields = struct { -// Time zapv2.Field[AdvanceTimeSchema, uint64] +// Time zapv1.Field[AdvanceTimeSchema, uint64] // }{ -// Time: zapv2.At[AdvanceTimeSchema, uint64](1), +// Time: zapv1.At[AdvanceTimeSchema, uint64](1), // } // // That's it. Wrap, Build, Read, Write are all expressed through the @@ -36,7 +36,7 @@ package examples import ( "github.com/luxfi/zap" - "github.com/luxfi/zap/v2" + "github.com/luxfi/zap/v1" ) // KindAdvanceTime is the wire discriminator for AdvanceTimeTx. It @@ -45,14 +45,14 @@ import ( // advance_time_tx_test.go pins this so the v2 generic builder // produces the exact same bytes as the v1 hand-rolled // NewAdvanceTimeTx. -const KindAdvanceTime zapv2.KindByte = 1 +const KindAdvanceTime zapv1.KindByte = 1 // AdvanceTimeSchema is the v2 schema marker for AdvanceTimeTx. The // type is the schema's identity; the methods describe its wire shape. type AdvanceTimeSchema struct{} // Kind returns the discriminator byte at object offset 0. -func (AdvanceTimeSchema) Kind() zapv2.KindByte { return KindAdvanceTime } +func (AdvanceTimeSchema) Kind() zapv1.KindByte { return KindAdvanceTime } // Size returns the fixed object payload (1 byte kind + 8 byte time). func (AdvanceTimeSchema) Size() int { return 9 } @@ -64,16 +64,16 @@ func (AdvanceTimeSchema) Name() string { return "AdvanceTimeTx" } // AdvanceTimeSchema. There is exactly ONE place where offsets are // declared; everywhere else uses these typed handles. // -// Reading: zapv2.Read(view, AdvanceTimeFields.Time) → uint64 -// Writing: zapv2.Write(setter, AdvanceTimeFields.Time, ts) +// Reading: zapv1.Read(view, AdvanceTimeFields.Time) → uint64 +// Writing: zapv1.Write(setter, AdvanceTimeFields.Time, ts) // // A compile error guards against using these handles with any view // other than View[AdvanceTimeSchema] — see // _compile_fail_test/cross_schema_field.go for the demonstration. var AdvanceTimeFields = struct { - Time zapv2.Field[AdvanceTimeSchema, uint64] + Time zapv1.Field[AdvanceTimeSchema, uint64] }{ - Time: zapv2.At[AdvanceTimeSchema, uint64](1), + Time: zapv1.At[AdvanceTimeSchema, uint64](1), } // NewAdvanceTime builds a fresh AdvanceTimeTx with the given @@ -87,12 +87,12 @@ var AdvanceTimeFields = struct { // itself). Result: matches v1's hand-rolled 1-alloc / 48-B profile. // // This pattern is what a codegen tool would emit per schema. The -// generic [zapv2.NewBuilderFor] / [zapv2.Build] paths are equivalent +// generic [zapv1.NewBuilderFor] / [zapv1.Build] paths are equivalent // in wire semantics but incur extra allocations because Go generics // hide the inlineable v1 primitives behind a non-inlineable shape // function — see the BENCH_RESULTS table for the measured cost // breakdown. -func NewAdvanceTime(ts uint64) (zapv2.View[AdvanceTimeSchema], []byte) { +func NewAdvanceTime(ts uint64) (zapv1.View[AdvanceTimeSchema], []byte) { const size = 9 // AdvanceTimeSchema{}.Size() b := zap.NewBuilder(zap.HeaderSize + size) ob := b.StartObject(size) @@ -101,7 +101,7 @@ func NewAdvanceTime(ts uint64) (zapv2.View[AdvanceTimeSchema], []byte) { rootOff := ob.FinishAsRoot() buf := b.Finish() end := rootOff + size - return zapv2.AsView[AdvanceTimeSchema](zapv2.RawFromSlices(buf, rootOff, end)), buf + return zapv1.AsView[AdvanceTimeSchema](zapv1.RawFromSlices(buf, rootOff, end)), buf } // NewAdvanceTimeClosure is the closure-style equivalent of @@ -109,9 +109,9 @@ func NewAdvanceTime(ts uint64) (zapv2.View[AdvanceTimeSchema], []byte) { // like English at the call site, at the cost of ~3 extra allocations // per Build. Use it for cold paths (CLI tools, test fixtures) and // reach for the imperative form on hot paths (per-block tx assembly). -func NewAdvanceTimeClosure(ts uint64) (zapv2.View[AdvanceTimeSchema], []byte) { - return zapv2.Build[AdvanceTimeSchema](func(s zapv2.Setter[AdvanceTimeSchema]) { - zapv2.Write(s, AdvanceTimeFields.Time, ts) +func NewAdvanceTimeClosure(ts uint64) (zapv1.View[AdvanceTimeSchema], []byte) { + return zapv1.Build[AdvanceTimeSchema](func(s zapv1.Setter[AdvanceTimeSchema]) { + zapv1.Write(s, AdvanceTimeFields.Time, ts) }) } @@ -119,28 +119,28 @@ func NewAdvanceTimeClosure(ts uint64) (zapv2.View[AdvanceTimeSchema], []byte) { // // Per-schema hand-rolled fast path: parses the wire frame inline, // validates the kind discriminator, and composes a typed -// [zapv2.View[AdvanceTimeSchema]]. Result: matches v1 hand-rolled +// [zapv1.View[AdvanceTimeSchema]]. Result: matches v1 hand-rolled // performance to within compiler noise. Zero heap allocs on the // happy path. // // Defense-in-depth: the explicit payload bounds check is folded into -// the per-Read bounds check that lives in [zapv2.Read] — wrapping a +// the per-Read bounds check that lives in [zapv1.Read] — wrapping a // short buffer succeeds, but any out-of-range Read returns the zero // value (matches v1 graceful-degradation semantics, see // [zap.Object.Uint64]). // // This pattern is what a codegen tool emits per schema. For cold // paths where ergonomics matter more than the last few ns, use the -// generic [zapv2.Wrap[AdvanceTimeSchema]] instead. -func WrapAdvanceTime(b []byte) (zapv2.View[AdvanceTimeSchema], error) { +// generic [zapv1.Wrap[AdvanceTimeSchema]] instead. +func WrapAdvanceTime(b []byte) (zapv1.View[AdvanceTimeSchema], error) { const size = 9 // AdvanceTimeSchema{}.Size() msg, err := zap.Parse(b) if err != nil { - return zapv2.View[AdvanceTimeSchema]{}, err + return zapv1.View[AdvanceTimeSchema]{}, err } root := msg.Root() if got := root.Uint8(0); got != uint8(KindAdvanceTime) { - return zapv2.View[AdvanceTimeSchema]{}, + return zapv1.View[AdvanceTimeSchema]{}, advanceTimeKindError(got) } data := msg.Bytes() @@ -149,8 +149,8 @@ func WrapAdvanceTime(b []byte) (zapv2.View[AdvanceTimeSchema], error) { if end > len(data) { end = len(data) } - return zapv2.AsView[AdvanceTimeSchema]( - zapv2.RawFromSlices(data, rootOff, end)), nil + return zapv1.AsView[AdvanceTimeSchema]( + zapv1.RawFromSlices(data, rootOff, end)), nil } // advanceTimeKindError builds the kind-mismatch error for @@ -159,9 +159,9 @@ func WrapAdvanceTime(b []byte) (zapv2.View[AdvanceTimeSchema], error) { // possible — when [WrapAdvanceTime] inlines into the caller, the // error path stays an out-of-line tail call. func advanceTimeKindError(got uint8) error { - return zapv2.NewSchemaError( - zapv2.KindByte(KindAdvanceTime), - zapv2.KindByte(got), + return zapv1.NewSchemaError( + zapv1.KindByte(KindAdvanceTime), + zapv1.KindByte(got), "AdvanceTimeTx") } @@ -169,15 +169,15 @@ func advanceTimeKindError(got uint8) error { // advance to. Zero copy, zero allocation. // // This is the value-side accessor — a thin one-line wrapper around -// zapv2.Read for callers who prefer method syntax. It is NOT what -// you'd write in a fresh project; just use zapv2.Read(view, Fields.X) +// zapv1.Read for callers who prefer method syntax. It is NOT what +// you'd write in a fresh project; just use zapv1.Read(view, Fields.X) // directly. Kept here so the example covers both forms. -func Time(v zapv2.View[AdvanceTimeSchema]) uint64 { - return zapv2.Read(v, AdvanceTimeFields.Time) +func Time(v zapv1.View[AdvanceTimeSchema]) uint64 { + return zapv1.Read(v, AdvanceTimeFields.Time) } func init() { // Register with the package-level Registry so generic dispatch // (PeekKind → Registry.Lookup → WrapAs) finds this schema. - zapv2.Register[AdvanceTimeSchema](zapv2.DefaultRegistry) + zapv1.Register[AdvanceTimeSchema](zapv1.DefaultRegistry) } diff --git a/v2/examples/batch_tx.go b/v1/examples/batch_tx.go similarity index 56% rename from v2/examples/batch_tx.go rename to v1/examples/batch_tx.go index 7301a91..a808c40 100644 --- a/v2/examples/batch_tx.go +++ b/v1/examples/batch_tx.go @@ -4,15 +4,15 @@ package examples import ( - "github.com/luxfi/zap/v2" + "github.com/luxfi/zap/v1" ) // KindBatch is the wire discriminator for BatchTx. Distinct from // KindAdvanceTime so Registry dispatch can tell them apart. -const KindBatch zapv2.KindByte = 0x21 +const KindBatch zapv1.KindByte = 0x21 // BatchSchema is a small, multi-element schema used to exercise the -// generic [zapv2.List] iter.Seq path in tests. Object layout: +// generic [zapv1.List] iter.Seq path in tests. Object layout: // // @0: KindBatch (uint8) // @1: BatchID (uint64) @@ -22,54 +22,54 @@ const KindBatch zapv2.KindByte = 0x21 // uint64). type BatchSchema struct{} -func (BatchSchema) Kind() zapv2.KindByte { return KindBatch } +func (BatchSchema) Kind() zapv1.KindByte { return KindBatch } func (BatchSchema) Size() int { return 17 } func (BatchSchema) Name() string { return "BatchTx" } // KindItem identifies ItemSchema. Items live inside BatchTx lists; an // Item is never a top-level message, but it has a Kind anyway so the // generic List[Item] code can use the same machinery. -const KindItem zapv2.KindByte = 0x22 +const KindItem zapv1.KindByte = 0x22 // ItemSchema is the per-element schema for BatchTx.Items. type ItemSchema struct{} -func (ItemSchema) Kind() zapv2.KindByte { return KindItem } +func (ItemSchema) Kind() zapv1.KindByte { return KindItem } func (ItemSchema) Size() int { return 16 } // 8 + 8 func (ItemSchema) Name() string { return "BatchItem" } // BatchFields declares the offsets for BatchSchema. var BatchFields = struct { - ID zapv2.Field[BatchSchema, uint64] + ID zapv1.Field[BatchSchema, uint64] }{ - ID: zapv2.At[BatchSchema, uint64](1), + ID: zapv1.At[BatchSchema, uint64](1), } // ItemFields declares the offsets for ItemSchema. var ItemFields = struct { - ID zapv2.Field[ItemSchema, uint64] - Value zapv2.Field[ItemSchema, uint64] + ID zapv1.Field[ItemSchema, uint64] + Value zapv1.Field[ItemSchema, uint64] }{ - ID: zapv2.At[ItemSchema, uint64](0), - Value: zapv2.At[ItemSchema, uint64](8), + ID: zapv1.At[ItemSchema, uint64](0), + Value: zapv1.At[ItemSchema, uint64](8), } // OffsetBatchItems is the byte offset of the list pointer for Items // within the BatchSchema fixed payload. Items is a variable-length -// list, so it lives outside the [zapv2.Field] generic vocabulary; it -// is read via [zapv2.ListAt] instead. +// list, so it lives outside the [zapv1.Field] generic vocabulary; it +// is read via [zapv1.ListAt] instead. const OffsetBatchItems uint32 = 9 // Items returns the list of items in the batch as an [iter.Seq]-ready -// [zapv2.List][ItemSchema]. Range-over-func: +// [zapv1.List][ItemSchema]. Range-over-func: // // for item := range examples.Items(batchView).All() { -// id := zapv2.Read(item, examples.ItemFields.ID) -// value := zapv2.Read(item, examples.ItemFields.Value) +// id := zapv1.Read(item, examples.ItemFields.ID) +// value := zapv1.Read(item, examples.ItemFields.Value) // // ... // } -func Items(v zapv2.View[BatchSchema]) zapv2.List[ItemSchema] { - return zapv2.ListAt[BatchSchema, ItemSchema](v, OffsetBatchItems) +func Items(v zapv1.View[BatchSchema]) zapv1.List[ItemSchema] { + return zapv1.ListAt[BatchSchema, ItemSchema](v, OffsetBatchItems) } // Item is a value-shaped helper for batch-construction tests. @@ -79,15 +79,15 @@ type Item struct { } // NewBatch builds a BatchTx with the given ID and items. -func NewBatch(id uint64, items []Item) (zapv2.View[BatchSchema], []byte) { - return zapv2.Build[BatchSchema](func(s zapv2.Setter[BatchSchema]) { - zapv2.Write(s, BatchFields.ID, id) - zapv2.WriteList[BatchSchema, ItemSchema](s, OffsetBatchItems, - func(es *zapv2.ElemSetter[ItemSchema]) { +func NewBatch(id uint64, items []Item) (zapv1.View[BatchSchema], []byte) { + return zapv1.Build[BatchSchema](func(s zapv1.Setter[BatchSchema]) { + zapv1.Write(s, BatchFields.ID, id) + zapv1.WriteList[BatchSchema, ItemSchema](s, OffsetBatchItems, + func(es *zapv1.ElemSetter[ItemSchema]) { for _, it := range items { - es.Append(func(e zapv2.Setter[ItemSchema]) { - zapv2.Write(e, ItemFields.ID, it.ID) - zapv2.Write(e, ItemFields.Value, it.Value) + es.Append(func(e zapv1.Setter[ItemSchema]) { + zapv1.Write(e, ItemFields.ID, it.ID) + zapv1.Write(e, ItemFields.Value, it.Value) }) } }) @@ -95,6 +95,6 @@ func NewBatch(id uint64, items []Item) (zapv2.View[BatchSchema], []byte) { } func init() { - zapv2.Register[BatchSchema](zapv2.DefaultRegistry) - zapv2.Register[ItemSchema](zapv2.DefaultRegistry) + zapv1.Register[BatchSchema](zapv1.DefaultRegistry) + zapv1.Register[ItemSchema](zapv1.DefaultRegistry) } diff --git a/v2/field.go b/v1/field.go similarity index 96% rename from v2/field.go rename to v1/field.go index 98a7de0..bafcb8b 100644 --- a/v2/field.go +++ b/v1/field.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2 +package zapv1 import ( "unsafe" @@ -32,7 +32,7 @@ import ( // methods of generic types ([View[S].Read[T] would be illegal]). v2 // therefore exposes Read and Write as top-level generic functions // rather than methods on [View] / [Setter]. The call site is at least -// as terse as a method call: `zapv2.Read(view, F.Time)`. +// as terse as a method call: `zapv1.Read(view, F.Time)`. type Field[S Schema, T FieldKind] struct { Offset uint32 // _phantom keeps the nominal type identity tight: without it the @@ -57,9 +57,9 @@ type phantomCarrier[S Schema, T FieldKind] struct { // fixed-size payload. Construct fields once per schema: // // var AdvanceTimeFields = struct { -// Time zapv2.Field[AdvanceTimeSchema, uint64] +// Time zapv1.Field[AdvanceTimeSchema, uint64] // }{ -// Time: zapv2.At[AdvanceTimeSchema, uint64](1), +// Time: zapv1.At[AdvanceTimeSchema, uint64](1), // } // // The offset is in bytes. The caller is responsible for keeping @@ -148,7 +148,7 @@ func init() { if *(*[2]byte)(unsafe.Pointer(&u)) != [2]byte{1, 0} { // readBE path would need to be wired here. The package // currently only targets little-endian platforms. - panic("zapv2: big-endian host detected; direct-load Read path " + + panic("zapv1: big-endian host detected; direct-load Read path " + "requires per-T byteswap (see field.go).") } } @@ -178,8 +178,8 @@ func Write[S Schema, T FieldKind](s Setter[S], f Field[S, T], val T) { // WriteB is the [Builder]-receiver counterpart to [Write]. Used in // the imperative-style build path: // -// bb := zapv2.NewBuilderFor[Schema]() -// zapv2.WriteB(bb, Fields.Time, ts) +// bb := zapv1.NewBuilderFor[Schema]() +// zapv1.WriteB(bb, Fields.Time, ts) // view, buf := bb.Finish() // // Identical wire semantics to Write — the difference is only that diff --git a/v2/iter.go b/v1/iter.go similarity index 99% rename from v2/iter.go rename to v1/iter.go index 9832732..1bee525 100644 --- a/v2/iter.go +++ b/v1/iter.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2 +package zapv1 import "iter" diff --git a/v2/list.go b/v1/list.go similarity index 94% rename from v2/list.go rename to v1/list.go index 4758db2..c3b54fa 100644 --- a/v2/list.go +++ b/v1/list.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2 +package zapv1 import ( "iter" @@ -62,7 +62,7 @@ func (l List[E]) At(i int) View[E] { // range-over-func form: // // for view := range list.All() { -// t := zapv2.Read(view, EFields.Time) +// t := zapv1.Read(view, EFields.Time) // // ... // } // @@ -122,7 +122,7 @@ func (l List[E]) All() iter.Seq[View[E]] { // Usage: // // for payload := range list.Payloads() { -// v := zapv2.ReadPayload[ItemSchema, uint64](payload, ItemFields.Value) +// v := zapv1.ReadPayload[ItemSchema, uint64](payload, ItemFields.Value) // // ... // } func (l List[E]) Payloads() iter.Seq[[]byte] { @@ -241,14 +241,14 @@ func rawListOffset(l zap.List) int { // // Example (BatchTx.Items, see examples/batch_tx.go): // -// zapv2.Build[BatchSchema](func(s zapv2.Setter[BatchSchema]) { -// zapv2.Write(s, BatchFields.ID, batchID) -// zapv2.WriteList[BatchSchema, ItemSchema](s, OffsetBatchItems, -// func(items *zapv2.ElemSetter[ItemSchema]) { +// zapv1.Build[BatchSchema](func(s zapv1.Setter[BatchSchema]) { +// zapv1.Write(s, BatchFields.ID, batchID) +// zapv1.WriteList[BatchSchema, ItemSchema](s, OffsetBatchItems, +// func(items *zapv1.ElemSetter[ItemSchema]) { // for _, it := range source { -// items.Append(func(e zapv2.Setter[ItemSchema]) { -// zapv2.Write(e, ItemFields.ID, it.id) -// zapv2.Write(e, ItemFields.Value, it.val) +// items.Append(func(e zapv1.Setter[ItemSchema]) { +// zapv1.Write(e, ItemFields.ID, it.id) +// zapv1.Write(e, ItemFields.Value, it.val) // }) // } // }) diff --git a/v2/pool.go b/v1/pool.go similarity index 95% rename from v2/pool.go rename to v1/pool.go index 48796e6..986d51b 100644 --- a/v2/pool.go +++ b/v1/pool.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2 +package zapv1 import "sync" @@ -9,7 +9,7 @@ import "sync" // dedicated sync.Pool + Get + Put per type as v1 did, register a // constructor once: // -// var ViewPool = zapv2.NewPool(func() *View[AdvanceTimeSchema] { +// var ViewPool = zapv1.NewPool(func() *View[AdvanceTimeSchema] { // return &View[AdvanceTimeSchema]{} // }) // diff --git a/v2/registry.go b/v1/registry.go similarity index 97% rename from v2/registry.go rename to v1/registry.go index 7d79a17..d26ae75 100644 --- a/v2/registry.go +++ b/v1/registry.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2 +package zapv1 import ( "sync" @@ -58,7 +58,7 @@ type Entry struct { // goroutines, but the typical pattern is init(): // // func init() { -// zapv2.Register[AdvanceTimeSchema](DefaultRegistry) +// zapv1.Register[AdvanceTimeSchema](DefaultRegistry) // } // // Register panics if two schemas declare the same kind byte — that @@ -72,7 +72,7 @@ func Register[S Schema](r *Registry) { r.mu.Lock() defer r.mu.Unlock() if existing, ok := r.entries[kind]; ok && existing.Name != name { - panic("zapv2: duplicate kind byte " + hexByte(byte(kind)) + + panic("zapv1: duplicate kind byte " + hexByte(byte(kind)) + " for schemas " + existing.Name + " and " + name) } r.entries[kind] = Entry{ diff --git a/v2/schema.go b/v1/schema.go similarity index 98% rename from v2/schema.go rename to v1/schema.go index 1dfea2e..37e4247 100644 --- a/v2/schema.go +++ b/v1/schema.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2 +package zapv1 // KindByte is the one-byte discriminator at offset 0 of every v2 // object payload. It identifies the schema concretely. @@ -70,7 +70,7 @@ type SchemaError struct { func (e *SchemaError) Error() string { // Keep the message terse and machine-grep-friendly: the kind bytes // are the load-bearing identity, the name is human help. - return "zapv2: schema mismatch: want " + e.Name + + return "zapv1: schema mismatch: want " + e.Name + " (kind=" + hexByte(byte(e.Want)) + "), got kind=" + hexByte(byte(e.Got)) } diff --git a/v2/v2_test.go b/v1/v2_test.go similarity index 72% rename from v2/v2_test.go rename to v1/v2_test.go index edb9ae8..1c71a67 100644 --- a/v2/v2_test.go +++ b/v1/v2_test.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2_test +package zapv1_test import ( "bytes" @@ -9,8 +9,8 @@ import ( "testing" "github.com/luxfi/zap" - "github.com/luxfi/zap/v2" - "github.com/luxfi/zap/v2/examples" + "github.com/luxfi/zap/v1" + "github.com/luxfi/zap/v1/examples" ) // TestRoundTrip_AdvanceTime: Build → Wrap → Read returns the original @@ -20,14 +20,14 @@ func TestRoundTrip_AdvanceTime(t *testing.T) { cases := []uint64{0, 1, 0xdeadbeef, 1<<63 - 1, 1<<64 - 1} for _, want := range cases { view, buf := examples.NewAdvanceTime(want) - if got := zapv2.Read(view, examples.AdvanceTimeFields.Time); got != want { + if got := zapv1.Read(view, examples.AdvanceTimeFields.Time); got != want { t.Fatalf("Build→Read: got %d, want %d", got, want) } view2, err := examples.WrapAdvanceTime(buf) if err != nil { t.Fatalf("Wrap: %v", err) } - if got := zapv2.Read(view2, examples.AdvanceTimeFields.Time); got != want { + if got := zapv1.Read(view2, examples.AdvanceTimeFields.Time); got != want { t.Fatalf("Build→Wrap→Read: got %d, want %d", got, want) } // Also exercise the method-style accessor. @@ -45,74 +45,74 @@ func TestRoundTrip_8Shapes(t *testing.T) { type s1 struct{} // Shape 1: bool field t.Run("Bool", func(t *testing.T) { - view, _ := zapv2.Build[boolSchema](func(set zapv2.Setter[boolSchema]) { - zapv2.Write(set, boolFields.Flag, true) + view, _ := zapv1.Build[boolSchema](func(set zapv1.Setter[boolSchema]) { + zapv1.Write(set, boolFields.Flag, true) }) - if !zapv2.Read(view, boolFields.Flag) { + if !zapv1.Read(view, boolFields.Flag) { t.Fatal("bool round-trip lost the value") } }) // Shape 2..N: integer widths. t.Run("Int8", func(t *testing.T) { const want int8 = -42 - view, _ := zapv2.Build[i8Schema](func(s zapv2.Setter[i8Schema]) { - zapv2.Write(s, i8Fields.V, want) + view, _ := zapv1.Build[i8Schema](func(s zapv1.Setter[i8Schema]) { + zapv1.Write(s, i8Fields.V, want) }) - if got := zapv2.Read(view, i8Fields.V); got != want { + if got := zapv1.Read(view, i8Fields.V); got != want { t.Fatalf("int8: %d != %d", got, want) } }) t.Run("Int16", func(t *testing.T) { const want int16 = -1234 - view, _ := zapv2.Build[i16Schema](func(s zapv2.Setter[i16Schema]) { - zapv2.Write(s, i16Fields.V, want) + view, _ := zapv1.Build[i16Schema](func(s zapv1.Setter[i16Schema]) { + zapv1.Write(s, i16Fields.V, want) }) - if got := zapv2.Read(view, i16Fields.V); got != want { + if got := zapv1.Read(view, i16Fields.V); got != want { t.Fatalf("int16: %d != %d", got, want) } }) t.Run("Int32", func(t *testing.T) { const want int32 = -7777777 - view, _ := zapv2.Build[i32Schema](func(s zapv2.Setter[i32Schema]) { - zapv2.Write(s, i32Fields.V, want) + view, _ := zapv1.Build[i32Schema](func(s zapv1.Setter[i32Schema]) { + zapv1.Write(s, i32Fields.V, want) }) - if got := zapv2.Read(view, i32Fields.V); got != want { + if got := zapv1.Read(view, i32Fields.V); got != want { t.Fatalf("int32: %d != %d", got, want) } }) t.Run("Int64", func(t *testing.T) { const want int64 = -(1 << 60) - view, _ := zapv2.Build[i64Schema](func(s zapv2.Setter[i64Schema]) { - zapv2.Write(s, i64Fields.V, want) + view, _ := zapv1.Build[i64Schema](func(s zapv1.Setter[i64Schema]) { + zapv1.Write(s, i64Fields.V, want) }) - if got := zapv2.Read(view, i64Fields.V); got != want { + if got := zapv1.Read(view, i64Fields.V); got != want { t.Fatalf("int64: %d != %d", got, want) } }) t.Run("Uint32", func(t *testing.T) { const want uint32 = 0xdeadbeef - view, _ := zapv2.Build[u32Schema](func(s zapv2.Setter[u32Schema]) { - zapv2.Write(s, u32Fields.V, want) + view, _ := zapv1.Build[u32Schema](func(s zapv1.Setter[u32Schema]) { + zapv1.Write(s, u32Fields.V, want) }) - if got := zapv2.Read(view, u32Fields.V); got != want { + if got := zapv1.Read(view, u32Fields.V); got != want { t.Fatalf("uint32: %x != %x", got, want) } }) t.Run("Float32", func(t *testing.T) { const want float32 = 3.14159 - view, _ := zapv2.Build[f32Schema](func(s zapv2.Setter[f32Schema]) { - zapv2.Write(s, f32Fields.V, want) + view, _ := zapv1.Build[f32Schema](func(s zapv1.Setter[f32Schema]) { + zapv1.Write(s, f32Fields.V, want) }) - if got := zapv2.Read(view, f32Fields.V); got != want { + if got := zapv1.Read(view, f32Fields.V); got != want { t.Fatalf("float32: %v != %v", got, want) } }) t.Run("Float64", func(t *testing.T) { const want float64 = 2.718281828459045 - view, _ := zapv2.Build[f64Schema](func(s zapv2.Setter[f64Schema]) { - zapv2.Write(s, f64Fields.V, want) + view, _ := zapv1.Build[f64Schema](func(s zapv1.Setter[f64Schema]) { + zapv1.Write(s, f64Fields.V, want) }) - if got := zapv2.Read(view, f64Fields.V); got != want { + if got := zapv1.Read(view, f64Fields.V); got != want { t.Fatalf("float64: %v != %v", got, want) } }) @@ -152,8 +152,8 @@ func TestByteEqual_V1Canonical(t *testing.T) { func TestWrap_WrongKind(t *testing.T) { t.Parallel() _, batchBuf := examples.NewAdvanceTime(7) // kind=1 - _, err := zapv2.Wrap[examples.BatchSchema](batchBuf) - var sErr *zapv2.SchemaError + _, err := zapv1.Wrap[examples.BatchSchema](batchBuf) + var sErr *zapv1.SchemaError if !errors.As(err, &sErr) { t.Fatalf("expected SchemaError, got %T: %v", err, err) } @@ -170,14 +170,14 @@ func TestRegistry_Dispatch(t *testing.T) { const want uint64 = 42 _, buf := examples.NewAdvanceTime(want) - kind, err := zapv2.PeekKind(buf) + kind, err := zapv1.PeekKind(buf) if err != nil { t.Fatalf("PeekKind: %v", err) } if kind != examples.KindAdvanceTime { t.Fatalf("PeekKind: got %v, want %v", kind, examples.KindAdvanceTime) } - entry, ok := zapv2.DefaultRegistry.Lookup(kind) + entry, ok := zapv1.DefaultRegistry.Lookup(kind) if !ok { t.Fatal("Registry: no entry for KindAdvanceTime") } @@ -188,11 +188,11 @@ func TestRegistry_Dispatch(t *testing.T) { t.Fatalf("entry.Wrap: %v", err) } // Final typed step. - view, err := zapv2.WrapAs[examples.AdvanceTimeSchema](buf) + view, err := zapv1.WrapAs[examples.AdvanceTimeSchema](buf) if err != nil { t.Fatalf("WrapAs: %v", err) } - if got := zapv2.Read(view, examples.AdvanceTimeFields.Time); got != want { + if got := zapv1.Read(view, examples.AdvanceTimeFields.Time); got != want { t.Fatalf("WrapAs round-trip: got %d, want %d", got, want) } } @@ -203,7 +203,7 @@ func TestPool_GenericGetPut(t *testing.T) { t.Parallel() type Box struct{ N int } created := 0 - pool := zapv2.NewPool(func() *Box { + pool := zapv1.NewPool(func() *Box { created++ return &Box{} }) @@ -241,7 +241,7 @@ func TestList_RangeOverFunc(t *testing.T) { } view, _ := examples.NewBatch(7777, want) - if id := zapv2.Read(view, examples.BatchFields.ID); id != 7777 { + if id := zapv1.Read(view, examples.BatchFields.ID); id != 7777 { t.Fatalf("BatchID: %d", id) } @@ -254,8 +254,8 @@ func TestList_RangeOverFunc(t *testing.T) { got := []examples.Item{} for itemView := range list.All() { got = append(got, examples.Item{ - ID: zapv2.Read(itemView, examples.ItemFields.ID), - Value: zapv2.Read(itemView, examples.ItemFields.Value), + ID: zapv1.Read(itemView, examples.ItemFields.ID), + Value: zapv1.Read(itemView, examples.ItemFields.Value), }) } if len(got) != len(want) { @@ -270,7 +270,7 @@ func TestList_RangeOverFunc(t *testing.T) { // Indexed iteration. seen := 0 for i, itemView := range list.Indexed() { - if got, w := zapv2.Read(itemView, examples.ItemFields.ID), want[i].ID; got != w { + if got, w := zapv1.Read(itemView, examples.ItemFields.ID), want[i].ID; got != w { t.Fatalf("Indexed item[%d].ID: %d, want %d", i, got, w) } seen++ @@ -282,7 +282,7 @@ func TestList_RangeOverFunc(t *testing.T) { // At(i) direct access. for i, w := range want { v := list.At(i) - if g := zapv2.Read(v, examples.ItemFields.ID); g != w.ID { + if g := zapv1.Read(v, examples.ItemFields.ID); g != w.ID { t.Fatalf("At(%d).ID: %d, want %d", i, g, w.ID) } } @@ -308,8 +308,8 @@ func TestList_LargeIteration(t *testing.T) { sumID := uint64(0) sumValue := uint64(0) for itemView := range list.All() { - sumID += zapv2.Read(itemView, examples.ItemFields.ID) - sumValue += zapv2.Read(itemView, examples.ItemFields.Value) + sumID += zapv1.Read(itemView, examples.ItemFields.ID) + sumValue += zapv1.Read(itemView, examples.ItemFields.Value) } wantSumID := uint64(N) * uint64(N-1) / 2 wantSumValue := wantSumID * 3 @@ -336,23 +336,23 @@ func TestIter_Combinators(t *testing.T) { list := examples.Items(view) // Take 3. - first3 := zapv2.Collect(zapv2.Take(list.All(), 3)) + first3 := zapv1.Collect(zapv1.Take(list.All(), 3)) if len(first3) != 3 { t.Fatalf("Take(3): got %d", len(first3)) } // Filter: only odd IDs. - odd := zapv2.Filter(list.All(), func(v zapv2.View[examples.ItemSchema]) bool { - return zapv2.Read(v, examples.ItemFields.ID)%2 == 1 + odd := zapv1.Filter(list.All(), func(v zapv1.View[examples.ItemSchema]) bool { + return zapv1.Read(v, examples.ItemFields.ID)%2 == 1 }) - if n := zapv2.Count(odd); n != 3 { // IDs 1, 3, 5 + if n := zapv1.Count(odd); n != 3 { // IDs 1, 3, 5 t.Fatalf("Filter odd: %d, want 3", n) } // Map: extract ID. - ids := zapv2.Collect(zapv2.Map(list.All(), - func(v zapv2.View[examples.ItemSchema]) uint64 { - return zapv2.Read(v, examples.ItemFields.ID) + ids := zapv1.Collect(zapv1.Map(list.All(), + func(v zapv1.View[examples.ItemSchema]) uint64 { + return zapv1.Read(v, examples.ItemFields.ID) })) if len(ids) != 5 || ids[0] != 1 || ids[4] != 5 { t.Fatalf("Map IDs: %v", ids) @@ -363,14 +363,14 @@ func TestIter_Combinators(t *testing.T) { // not panic on accessor calls. func TestIsZero(t *testing.T) { t.Parallel() - var v zapv2.View[examples.AdvanceTimeSchema] + var v zapv1.View[examples.AdvanceTimeSchema] if !v.IsZero() { t.Fatal("zero View should be IsZero") } - if got := zapv2.Read(v, examples.AdvanceTimeFields.Time); got != 0 { + if got := zapv1.Read(v, examples.AdvanceTimeFields.Time); got != 0 { t.Fatalf("zero View Read: got %d, want 0", got) } - var l zapv2.List[examples.ItemSchema] + var l zapv1.List[examples.ItemSchema] if !l.IsZero() { t.Fatal("zero List should be IsZero") } @@ -383,80 +383,80 @@ func TestIsZero(t *testing.T) { type boolSchema struct{} -func (boolSchema) Kind() zapv2.KindByte { return 0xC0 } +func (boolSchema) Kind() zapv1.KindByte { return 0xC0 } func (boolSchema) Size() int { return 2 } func (boolSchema) Name() string { return "boolSchema" } var boolFields = struct { - Flag zapv2.Field[boolSchema, bool] -}{Flag: zapv2.At[boolSchema, bool](1)} + Flag zapv1.Field[boolSchema, bool] +}{Flag: zapv1.At[boolSchema, bool](1)} type i8Schema struct{} -func (i8Schema) Kind() zapv2.KindByte { return 0xC1 } +func (i8Schema) Kind() zapv1.KindByte { return 0xC1 } func (i8Schema) Size() int { return 2 } func (i8Schema) Name() string { return "i8Schema" } var i8Fields = struct { - V zapv2.Field[i8Schema, int8] -}{V: zapv2.At[i8Schema, int8](1)} + V zapv1.Field[i8Schema, int8] +}{V: zapv1.At[i8Schema, int8](1)} type i16Schema struct{} -func (i16Schema) Kind() zapv2.KindByte { return 0xC2 } +func (i16Schema) Kind() zapv1.KindByte { return 0xC2 } func (i16Schema) Size() int { return 4 } func (i16Schema) Name() string { return "i16Schema" } var i16Fields = struct { - V zapv2.Field[i16Schema, int16] -}{V: zapv2.At[i16Schema, int16](2)} + V zapv1.Field[i16Schema, int16] +}{V: zapv1.At[i16Schema, int16](2)} type i32Schema struct{} -func (i32Schema) Kind() zapv2.KindByte { return 0xC3 } +func (i32Schema) Kind() zapv1.KindByte { return 0xC3 } func (i32Schema) Size() int { return 8 } func (i32Schema) Name() string { return "i32Schema" } var i32Fields = struct { - V zapv2.Field[i32Schema, int32] -}{V: zapv2.At[i32Schema, int32](4)} + V zapv1.Field[i32Schema, int32] +}{V: zapv1.At[i32Schema, int32](4)} type i64Schema struct{} -func (i64Schema) Kind() zapv2.KindByte { return 0xC4 } +func (i64Schema) Kind() zapv1.KindByte { return 0xC4 } func (i64Schema) Size() int { return 16 } func (i64Schema) Name() string { return "i64Schema" } var i64Fields = struct { - V zapv2.Field[i64Schema, int64] -}{V: zapv2.At[i64Schema, int64](8)} + V zapv1.Field[i64Schema, int64] +}{V: zapv1.At[i64Schema, int64](8)} type u32Schema struct{} -func (u32Schema) Kind() zapv2.KindByte { return 0xC5 } +func (u32Schema) Kind() zapv1.KindByte { return 0xC5 } func (u32Schema) Size() int { return 8 } func (u32Schema) Name() string { return "u32Schema" } var u32Fields = struct { - V zapv2.Field[u32Schema, uint32] -}{V: zapv2.At[u32Schema, uint32](4)} + V zapv1.Field[u32Schema, uint32] +}{V: zapv1.At[u32Schema, uint32](4)} type f32Schema struct{} -func (f32Schema) Kind() zapv2.KindByte { return 0xC6 } +func (f32Schema) Kind() zapv1.KindByte { return 0xC6 } func (f32Schema) Size() int { return 8 } func (f32Schema) Name() string { return "f32Schema" } var f32Fields = struct { - V zapv2.Field[f32Schema, float32] -}{V: zapv2.At[f32Schema, float32](4)} + V zapv1.Field[f32Schema, float32] +}{V: zapv1.At[f32Schema, float32](4)} type f64Schema struct{} -func (f64Schema) Kind() zapv2.KindByte { return 0xC7 } +func (f64Schema) Kind() zapv1.KindByte { return 0xC7 } func (f64Schema) Size() int { return 16 } func (f64Schema) Name() string { return "f64Schema" } var f64Fields = struct { - V zapv2.Field[f64Schema, float64] -}{V: zapv2.At[f64Schema, float64](8)} + V zapv1.Field[f64Schema, float64] +}{V: zapv1.At[f64Schema, float64](8)} diff --git a/v2/view.go b/v1/view.go similarity index 99% rename from v2/view.go rename to v1/view.go index fb01a2d..9ba8309 100644 --- a/v2/view.go +++ b/v1/view.go @@ -1,7 +1,7 @@ // Copyright (C) 2026, Lux Industries Inc. All rights reserved. // See the file LICENSE for licensing terms. -package zapv2 +package zapv1 import ( "unsafe" diff --git a/zap.go b/zap.go index cd1f89d..ed0871b 100644 --- a/zap.go +++ b/zap.go @@ -153,7 +153,7 @@ func (m *Message) Version() uint16 { // ParseHeader validates a ZAP wire frame and returns the (validated // data slice, root offset) WITHOUT allocating a [*Message]. Same checks // as [Parse] — magic, version, size — but the result is two values, not -// a pointer. Intended for generic wrappers (zapv2) that build their own +// a pointer. Intended for generic wrappers (zapv1) that build their own // value-typed accessors and never need a *Message. // // Returns (data[:size], rootOff, nil) on success. @@ -162,7 +162,7 @@ func (m *Message) Version() uint16 { // size + bounds). The implementation is intentionally written as one // linear sequence (no intermediate function calls) so the inliner // folds the whole body into the caller. Combined with the value- -// typed [zapv2.View], this is what makes the v2 read path match v1's +// typed [zapv1.View], this is what makes the v2 read path match v1's // 2 ns hand-rolled per-Read cost — zero function calls, zero heap. func ParseHeader(data []byte) ([]byte, int, error) { return parseHeaderImpl(data) @@ -206,7 +206,7 @@ func WrapBuffer(data []byte) *Message { } // RootObjectAt returns a [zap.Object] anchored at absolute offset -// `off` within this message. Used by zapv2.Build to avoid a redundant +// `off` within this message. Used by zapv1.Build to avoid a redundant // header-read after [Builder.FinishAsRoot] already returned the root // position. func (m *Message) RootObjectAt(off int) Object { @@ -281,7 +281,7 @@ func (o Object) IsNull() bool { } // Offset returns the object's absolute byte offset within its -// underlying message. Exposed so external generic wrappers (zapv2) +// underlying message. Exposed so external generic wrappers (zapv1) // can construct typed sub-views into the same buffer without // re-walking the parent pointers. // @@ -294,7 +294,7 @@ func (o Object) Offset() int { } // Message returns the underlying [*Message] this Object is a view -// into. Used by zapv2 to alias the message's bytes for direct +// into. Used by zapv1 to alias the message's bytes for direct // payload indexing. func (o Object) Message() *Message { return o.msg