@xyo-network/payload-model 5.1.22 → 5.1.24

package/dist/neutral/PayloadBundle.d.ts

@@ -9,5 +9,5 @@ export interface PayloadBundleFields<T extends Payload = Payload> {
 export type PayloadBundle = Payload<PayloadBundleFields, PayloadBundleSchema>;
 export declare const isPayloadBundle: (x?: unknown | null) => x is PayloadBundle;
 export declare const asPayloadBundle: import("@xylabs/object").AsTypeFunction<PayloadBundle>;
-export declare const asOptionalPayloadBundle: (value: import(".store/@xylabs-promise-npm-5.0.24-e9749bb6a6/package").AnyNonPromise) => PayloadBundle | undefined;
+export declare const asOptionalPayloadBundle: (value: import(".store/@xylabs-promise-npm-5.0.37-e0d0dd2b09/package").AnyNonPromise) => PayloadBundle | undefined;
 //# sourceMappingURL=PayloadBundle.d.ts.map

package/dist/neutral/StorageMeta/DataHash.d.ts

@@ -7,7 +7,7 @@ export type WithDataHashMeta<T extends Payload = Payload> = T & DataHashMeta;
 export type WithPartialDataHashMeta<T extends Payload = Payload> = Partial<WithDataHashMeta<T>>;
 export declare const isDataHashMeta: (value: unknown) => value is DataHashMeta;
 export declare const asDataHashMeta: import("@xylabs/object").AsTypeFunction<DataHashMeta>;
-export declare const asOptionalDataHashMeta: (value: import(".store/@xylabs-promise-npm-5.0.24-e9749bb6a6/package").AnyNonPromise) => DataHashMeta | undefined;
+export declare const asOptionalDataHashMeta: (value: import(".store/@xylabs-promise-npm-5.0.37-e0d0dd2b09/package").AnyNonPromise) => DataHashMeta | undefined;
 /** @deprecated use DataHashMeta instead */
 export interface DataHashStorageMeta extends DataHashMeta {
 }
@@ -20,5 +20,5 @@ export declare const isDataHashStorageMeta: (value: unknown) => value is DataHas
 /** @deprecated use asDataHashMeta instead */
 export declare const asDataHashStorageMeta: import("@xylabs/object").AsTypeFunction<DataHashMeta>;
 /** @deprecated use asOptionalDataHashMeta instead */
-export declare const asOptionalDataHashStorageMeta: (value: import(".store/@xylabs-promise-npm-5.0.24-e9749bb6a6/package").AnyNonPromise) => DataHashMeta | undefined;
+export declare const asOptionalDataHashStorageMeta: (value: import(".store/@xylabs-promise-npm-5.0.37-e0d0dd2b09/package").AnyNonPromise) => DataHashMeta | undefined;
 //# sourceMappingURL=DataHash.d.ts.map

package/dist/neutral/StorageMeta/Hash.d.ts

@@ -8,7 +8,7 @@ export type WithHashMeta<T extends Payload = Payload> = T & HashMeta;
 export type WithPartialHashMeta<T extends Payload = Payload> = Partial<WithHashMeta<T>>;
 export declare const isHashMeta: (value: unknown) => value is HashMeta;
 export declare const asHashMeta: import("@xylabs/object").AsTypeFunction<HashMeta>;
-export declare const asOptionalHashMeta: (value: import(".store/@xylabs-promise-npm-5.0.24-e9749bb6a6/package").AnyNonPromise) => HashMeta | undefined;
+export declare const asOptionalHashMeta: (value: import(".store/@xylabs-promise-npm-5.0.37-e0d0dd2b09/package").AnyNonPromise) => HashMeta | undefined;
 /** @deprecated use HashMeta instead */
 export interface HashStorageMeta extends HashMeta {
 }
@@ -21,5 +21,5 @@ export declare const isHashStorageMeta: (value: unknown) => value is HashMeta;
 /** @deprecated use asHashMeta instead */
 export declare const asHashStorageMeta: import("@xylabs/object").AsTypeFunction<HashMeta>;
 /** @deprecated use asOptionalHashMeta instead */
-export declare const asOptionalHashStorageMeta: (value: import(".store/@xylabs-promise-npm-5.0.24-e9749bb6a6/package").AnyNonPromise) => HashMeta | undefined;
+export declare const asOptionalHashStorageMeta: (value: import(".store/@xylabs-promise-npm-5.0.37-e0d0dd2b09/package").AnyNonPromise) => HashMeta | undefined;
 //# sourceMappingURL=Hash.d.ts.map

package/dist/neutral/StorageMeta/Sequence.d.ts

@@ -7,5 +7,5 @@ export type WithSequenceStorageMeta<T extends Payload = Payload> = T & SequenceS
 export type WithPartialSequenceStorageMeta<T extends Payload = Payload> = Partial<WithSequenceStorageMeta<T>>;
 export declare const isSequenceStorageMeta: (value: unknown) => value is SequenceStorageMeta;
 export declare const asSequenceStorageMeta: import("@xylabs/object").AsTypeFunction<SequenceStorageMeta>;
-export declare const asOptionalSequenceStorageMeta: (value: import(".store/@xylabs-promise-npm-5.0.24-e9749bb6a6/package").AnyNonPromise) => SequenceStorageMeta | undefined;
+export declare const asOptionalSequenceStorageMeta: (value: import(".store/@xylabs-promise-npm-5.0.37-e0d0dd2b09/package").AnyNonPromise) => SequenceStorageMeta | undefined;
 //# sourceMappingURL=Sequence.d.ts.map

package/dist/neutral/StorageMeta/StorageMeta.d.ts

@@ -7,5 +7,5 @@ export type WithStorageMeta<T extends Payload = Payload> = T & StorageMeta;
 export type WithPartialStorageMeta<T extends Payload = Payload> = T & Partial<StorageMeta>;
 export declare const isStorageMeta: (value: unknown) => value is StorageMeta;
 export declare const asStorageMeta: import("@xylabs/object").AsTypeFunction<StorageMeta>;
-export declare const asOptionalStorageMeta: (value: import(".store/@xylabs-promise-npm-5.0.24-e9749bb6a6/package").AnyNonPromise) => StorageMeta | undefined;
+export declare const asOptionalStorageMeta: (value: import(".store/@xylabs-promise-npm-5.0.37-e0d0dd2b09/package").AnyNonPromise) => StorageMeta | undefined;
 //# sourceMappingURL=StorageMeta.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/payload-model",
-  "version": "5.1.22",
+  "version": "5.1.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,22 +30,25 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src"
+    "src",
+    "!**/*.bench.*",
+    "!**/*.spec.*",
+    "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/arraybuffer": "~5.0.24",
-    "@xylabs/assert": "~5.0.24",
-    "@xylabs/hex": "~5.0.24",
-    "@xylabs/object": "~5.0.24",
-    "@xylabs/typeof": "~5.0.24",
+    "@xylabs/arraybuffer": "~5.0.37",
+    "@xylabs/assert": "~5.0.37",
+    "@xylabs/hex": "~5.0.37",
+    "@xylabs/object": "~5.0.37",
+    "@xylabs/typeof": "~5.0.37",
     "zod": "~4.1.12"
   },
   "devDependencies": {
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.24",
+    "@xylabs/vitest-extended": "~5.0.37",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.8"
+    "vitest": "~4.0.10"
   },
   "publishConfig": {
     "access": "public"

package/dist/neutral/StorageMeta/spec/SequenceComparer.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=SequenceComparer.spec.d.ts.map

package/dist/neutral/StorageMeta/spec/SequenceComparer.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SequenceComparer.spec.d.ts","sourceRoot":"","sources":["../../../../src/StorageMeta/spec/SequenceComparer.spec.ts"],"names":[],"mappings":""}

package/dist/neutral/StorageMeta/spec/SequenceMeta.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=SequenceMeta.spec.d.ts.map

package/dist/neutral/StorageMeta/spec/SequenceMeta.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SequenceMeta.spec.d.ts","sourceRoot":"","sources":["../../../../src/StorageMeta/spec/SequenceMeta.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/StorageMeta/spec/SequenceParser.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=SequenceParser.spec.d.ts.map

package/dist/neutral/StorageMeta/spec/SequenceParser.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SequenceParser.spec.d.ts","sourceRoot":"","sources":["../../../../src/StorageMeta/spec/SequenceParser.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/spec/Payload.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=Payload.spec.d.ts.map

package/dist/neutral/spec/Payload.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Payload.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/Payload.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/spec/isPayloadOfZodType.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=isPayloadOfZodType.spec.d.ts.map

package/dist/neutral/spec/isPayloadOfZodType.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPayloadOfZodType.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/isPayloadOfZodType.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/src/StorageMeta/spec/SequenceComparer.spec.ts

@@ -1,101 +0,0 @@
-// SequenceComparer.spec.ts
-
-import type { Address } from '@xylabs/hex'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import type {
-  Epoch, Nonce, Sequence,
-} from '../sequence/index.ts'
-import {
-  SequenceComparer,
-  SequenceParser,
-} from '../sequence/index.ts'
-
-describe('SequenceComparer', () => {
-  describe('local', () => {
-    const epochA = '0000000000000001' as Epoch
-    const epochB = '0000000000000002' as Epoch
-
-    const nonceX = '000000000000000a' as Nonce
-    const nonceY = '000000000000000b' as Nonce
-
-    const seqAX: Sequence = SequenceParser.from(epochA, nonceX).localSequence // local sequence #1
-    const seqAY: Sequence = SequenceParser.from(epochA, nonceY).localSequence // local sequence #2
-    const seqBX: Sequence = SequenceParser.from(epochB, nonceX).localSequence // local sequence #3
-
-    it('should return 0 when local sequences are equal', () => {
-      expect(SequenceComparer.local(seqAX, seqAX)).toBe(0)
-    })
-
-    it('should return a negative number if first local sequence < second by local sequence value', () => {
-      // Compare seqAX to seqAY (they differ in nonce)
-      const result = SequenceComparer.local(seqAX, seqAY)
-      expect(result).toBeLessThan(0)
-    })
-
-    it('should return a positive number if first local sequence > second by local sequence value', () => {
-      // Compare seqAY to seqAX (they differ in nonce)
-      const result = SequenceComparer.local(seqAY, seqAX)
-      expect(result).toBeGreaterThan(0)
-    })
-
-    it('should consider epoch differences if nonce is the same', () => {
-      // seqAX vs seqBX differ by epoch
-      const result = SequenceComparer.local(seqAX, seqBX)
-      expect(result).toBeLessThan(0)
-
-      const reverseResult = SequenceComparer.local(seqBX, seqAX)
-      expect(reverseResult).toBeGreaterThan(0)
-    })
-  })
-
-  describe('qualified', () => {
-    const epochC = '0000000000000010' as Epoch
-    const epochD = '0000000000000011' as Epoch
-
-    const nonceM = '000000000000000f' as Nonce
-    const nonceN = '000000000000001f' as Nonce
-
-    const address1 = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' as Address
-    const address2 = '0000000000000000000000000000000000000000' as Address
-
-    const seqCMA: Sequence = SequenceParser.from(epochC, nonceM, address1).qualifiedSequence // qualified seq #1
-    const seqCNA: Sequence = SequenceParser.from(epochC, nonceN, address1).qualifiedSequence // qualified seq #2
-    const seqDMB: Sequence = SequenceParser.from(epochD, nonceM, address2).qualifiedSequence // qualified seq #3
-
-    it('should return 0 when qualified sequences are equal', () => {
-      expect(SequenceComparer.qualified(seqCMA, seqCMA)).toBe(0)
-    })
-
-    it('should return a negative number if the first qualified sequence < second by full sequence value', () => {
-      // Compare sequences differing by nonce
-      const result = SequenceComparer.qualified(seqCMA, seqCNA)
-      expect(result).toBeLessThan(0)
-    })
-
-    it('should return a positive number if the first qualified sequence > second by full sequence value', () => {
-      // Compare reversed
-      const result = SequenceComparer.qualified(seqCNA, seqCMA)
-      expect(result).toBeGreaterThan(0)
-    })
-
-    it('should consider address differences if epoch and nonce are identical', () => {
-      // Create two sequences differing only by address
-      const seqCMA2 = SequenceParser.from(epochC, nonceM, address2).qualifiedSequence
-      const result = SequenceComparer.qualified(seqCMA, seqCMA2)
-      // Since address1 ('a...') > address2 ('0...'), we expect a positive result
-      expect(result).toBeGreaterThan(0)
-    })
-
-    it('should consider epoch differences', () => {
-      // seqCMA vs seqDMB differ by epoch
-      const result = SequenceComparer.qualified(seqCMA, seqDMB)
-      expect(result).toBeLessThan(0)
-
-      const reverseResult = SequenceComparer.qualified(seqDMB, seqCMA)
-      expect(reverseResult).toBeGreaterThan(0)
-    })
-  })
-})

package/src/StorageMeta/spec/SequenceMeta.spec.ts

@@ -1,40 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { SequenceComponentMinMax } from '../sequence/index.ts'
-
-describe('SequenceParser', () => {
-  describe('minEpoch', () => {
-    it('minEpoch', () => {
-      expect(SequenceComponentMinMax.minEpoch).toEqual('0000000000000000')
-    })
-  })
-  describe('maxEpoch', () => {
-    it('maxEpoch', () => {
-      expect(SequenceComponentMinMax.maxEpoch).toEqual('ffffffffffffffff')
-    })
-  })
-  describe('minNonce', () => {
-    it('minNonce', () => {
-      expect(SequenceComponentMinMax.minNonce).toEqual('0000000000000000')
-    })
-  })
-  describe('maxNonce', () => {
-    it('maxNonce', () => {
-      expect(SequenceComponentMinMax.maxNonce).toEqual('ffffffffffffffff')
-    })
-  })
-  describe('minAddress', () => {
-    it('minAddress', () => {
-      expect(SequenceComponentMinMax.minAddress).toEqual('0000000000000000000000000000000000000000')
-    })
-  })
-  describe('maxAddress', () => {
-    it('maxAddress', () => {
-      expect(SequenceComponentMinMax.maxAddress).toEqual('ffffffffffffffffffffffffffffffffffffffff')
-    })
-  })
-})

package/src/StorageMeta/spec/SequenceParser.spec.ts

@@ -1,113 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import type { Address, Hash } from '@xylabs/hex'
-import {
-  asAddress, asHash, toHex,
-} from '@xylabs/hex'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { SequenceConstants, SequenceParser } from '../sequence/index.ts'
-
-describe('SequenceParser', () => {
-  const hash: Hash = asHash('1269b95d3ebf1b1258a82ccca0b365fabf4b8c99bf8fc852e5045e30ad20fbb1', true)
-  const address = asAddress('b36d327210f67ad98be881ddf6ad1f1b3e2c5137', true)
-  const timestamp = 1_234_567_890_123
-  const parsed: SequenceParser = SequenceParser.from(timestamp, hash, address)
-  const parsedWithIndex: SequenceParser = SequenceParser.from(timestamp, hash, 5, address)
-
-  describe('epoch', () => {
-    it('converts timestamp to epoch correctly', () => {
-      expect(parsed.epoch).toBe(SequenceParser.toEpoch(timestamp))
-      expect(parsed.epoch).toBe('0000011f71fb04cb')
-    })
-  })
-
-  describe('from', () => {
-    it('parses sequence from timestamp and hash correctly', () => {
-      const parsed = SequenceParser.from(timestamp, hash)
-      const timestampHex = SequenceParser.toEpoch(timestamp)
-      const nonceHex = SequenceParser.toNonce(hash)
-      expect(parsed.localSequence).toBe(`${timestampHex}${nonceHex}`)
-      expect(parsed.localSequence).toBe('0000011f71fb04cb00000000ad20fbb1')
-    })
-    it('parses sequence from timestamp, hash, and address correctly', () => {
-      const parsed = SequenceParser.from(timestamp, hash, address)
-      const timestampHex = SequenceParser.toEpoch(timestamp)
-      const nonceHex = SequenceParser.toNonce(hash)
-      expect(parsed.localSequence).toBe(`${timestampHex}${nonceHex}`)
-      expect(parsed.localSequence).toBe('0000011f71fb04cb00000000ad20fbb1')
-      expect(parsed.qualifiedSequence).toBe(`${timestampHex}${nonceHex}${address}`)
-      expect(parsed.qualifiedSequence).toBe('0000011f71fb04cb00000000ad20fbb1b36d327210f67ad98be881ddf6ad1f1b3e2c5137')
-    })
-    it('parses sequence from timestamp, hash, index, and address correctly', () => {
-      const parsed = SequenceParser.from(timestamp, hash, 5, address)
-      const timestampHex = SequenceParser.toEpoch(timestamp)
-      const nonceHex = SequenceParser.toNonce(hash, 5)
-      expect(parsed.localSequence).toBe(`${timestampHex}${nonceHex}`)
-      expect(parsed.localSequence).toBe('0000011f71fb04cb00000005ad20fbb1')
-      expect(parsed.qualifiedSequence).toBe(`${timestampHex}${nonceHex}${address}`)
-      expect(parsed.qualifiedSequence).toBe('0000011f71fb04cb00000005ad20fbb1b36d327210f67ad98be881ddf6ad1f1b3e2c5137')
-    })
-    it('equivalently parses two local sequences with and without address', () => {
-      const withAddress = SequenceParser.from(timestamp, hash, address)
-      const withoutAddress = SequenceParser.from(timestamp, hash)
-      expect(withAddress.localSequence).toEqual(withoutAddress.localSequence)
-    })
-    it('equivalently parses two local sequences with and without address (with index)', () => {
-      const withAddress = SequenceParser.from(timestamp, hash, 8, address)
-      const withoutAddress = SequenceParser.from(timestamp, hash, 8)
-      expect(withAddress.localSequence).toEqual(withoutAddress.localSequence)
-    })
-    it('equivalently parses two qualified sequences with and without address', () => {
-      const address = '0'.repeat(SequenceConstants.addressBytes * 2) as Address
-      const withAddress = SequenceParser.from(timestamp, hash, address)
-      const withoutAddress = SequenceParser.from(timestamp, hash)
-      expect(withAddress.qualifiedSequence).toEqual(withoutAddress.qualifiedSequence)
-    })
-    it('equivalently parses two qualified sequences with and without address (with index)', () => {
-      const address = '0'.repeat(SequenceConstants.addressBytes * 2) as Address
-      const withAddress = SequenceParser.from(timestamp, hash, 9, address)
-      const withoutAddress = SequenceParser.from(timestamp, hash, 9)
-      expect(withAddress.qualifiedSequence).toEqual(withoutAddress.qualifiedSequence)
-    })
-  })
-
-  describe('nonce', () => {
-    it('derives nonce from hash correctly', () => {
-      expect(parsed.nonce).toBe(SequenceParser.toNonce(hash))
-      expect(parsed.nonce).toBe(toHex(0, { bitLength: SequenceConstants.nonceIndexBytes * 8 }) + hash.slice(-SequenceConstants.nonceHashBytes * 2))
-      expect(parsed.nonce).toBe('00000000ad20fbb1')
-    })
-
-    it('derives nonce from hash correctly', () => {
-      expect(parsedWithIndex.nonce).toBe(SequenceParser.toNonce(hash, 5))
-      expect(parsedWithIndex.nonce).toBe(toHex(5, { bitLength: SequenceConstants.nonceIndexBytes * 8 }) + hash.slice(-SequenceConstants.nonceHashBytes * 2))
-      expect(parsedWithIndex.nonce).toBe('00000005ad20fbb1')
-    })
-  })
-
-  describe('address', () => {
-    it('stores the address correctly', () => {
-      expect(parsed.address).toBe(address)
-    })
-  })
-
-  describe('localSequence', () => {
-    it('concatenates epoch and nonce correctly', () => {
-      expect(parsed.localSequence).toBe(`${parsed.epoch}${parsed.nonce}`)
-      expect(parsed.localSequence).toBe('0000011f71fb04cb00000000ad20fbb1')
-    })
-  })
-
-  describe('qualifiedSequence', () => {
-    it('concatenates localSequence and address correctly', () => {
-      expect(parsed.qualifiedSequence).toBe(`${parsed.epoch}${parsed.nonce}${parsed.address}`)
-      expect(parsed.qualifiedSequence).toBe(`${parsed.localSequence}${parsed.address}`)
-      expect(parsed.qualifiedSequence).toBe(
-        '0000011f71fb04cb00000000ad20fbb1b36d327210f67ad98be881ddf6ad1f1b3e2c5137',
-      )
-    })
-  })
-})

package/src/spec/Payload.spec.ts

@@ -1,26 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import type { Payload } from '../Payload.ts'
-
-const TestPayloadSchema = 'com.test.schema'
-type TestPayloadSchema = typeof TestPayloadSchema
-
-type TestPayload = Payload<{ data: { foo: string } }, TestPayloadSchema>
-
-/* These tests are just to see if casting works as expected */
-
-describe('Payload Types', () => {
-  it('WithMeta', () => {
-    const payload: TestPayload = { data: { foo: 'bar' }, schema: 'com.test.schema' }
-    const payloadWithMeta: TestPayload = {
-      $hash: '123', $meta: { test: 'yo' }, data: { foo: 'bar' }, schema: 'com.test.schema',
-    } as TestPayload
-    const payloadFromWithMeta: TestPayload = payloadWithMeta
-    expect(payload).toBeDefined()
-    expect(payloadFromWithMeta).toBeDefined()
-  })
-})

package/src/spec/isPayloadOfZodType.spec.ts

@@ -1,35 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import {
-  describe, expect, it,
-} from 'vitest'
-import z from 'zod'
-
-import { isPayloadOfZodType } from '../isPayloadOfZodType.ts'
-import type { Payload } from '../Payload.ts'
-
-const TestPayloadSchema = 'com.test.schema'
-type TestPayloadSchema = typeof TestPayloadSchema
-
-type TestPayload = Payload<{ data: { foo: string } }, TestPayloadSchema>
-
-const TestPayloadZod = z.object({ data: z.object({ foo: z.string() }) })
-
-/* These tests are just to see if casting works as expected */
-
-describe('isPayloadOfZodType', () => {
-  const payload: TestPayload = { data: { foo: 'bar' }, schema: 'com.test.schema' }
-  const payloadWithMeta: TestPayload = {
-    $hash: '123', $meta: { test: 'yo' }, data: { foo: 'bar' }, schema: 'com.test.schema',
-  } as TestPayload
-  it('with schema supplied', () => {
-    const identity = isPayloadOfZodType<TestPayload>(TestPayloadZod, TestPayloadSchema)
-    expect(identity(payload)).toBeTrue()
-    expect(identity(payloadWithMeta)).toBeTrue()
-  })
-  it('without schema supplied', () => {
-    const identity = isPayloadOfZodType<TestPayload>(TestPayloadZod)
-    expect(identity(payload)).toBeTrue()
-    expect(identity(payloadWithMeta)).toBeTrue()
-  })
-})