@xyo-network/xl1-protocol 5.1.3 → 5.2.0

package/dist/neutral/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.d.ts

@@ -24,6 +24,7 @@ export declare const UnsignedBlockBoundWitnessZod: z.ZodMiniObject<{
     previous: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
     protocol: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
     step_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+    supersedes: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
     $epoch: z.ZodMiniNumber<number>;
 }, z.core.$strip>;
 /** Validated data representation for Unsigned Block Bound Witness. */
@@ -54,6 +55,7 @@ export declare const isUnsignedBlockBoundWitness: <T>(value: T) => value is T &
     $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
     protocol?: number | undefined;
     step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
 };
 /** Converts a value to UnsignedBlockBoundWitness, throwing if invalid. */
 export declare const asUnsignedBlockBoundWitness: {
@@ -82,6 +84,7 @@ export declare const asUnsignedBlockBoundWitness: {
         $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
     }) | undefined;
     <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
         schema: "network.xyo.boundwitness" & {
@@ -108,6 +111,7 @@ export declare const asUnsignedBlockBoundWitness: {
         $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
     };
 };
 /** Safe conversion helper that returns Unsigned Block Bound Witness when validation succeeds and `undefined` otherwise. */
@@ -137,6 +141,7 @@ export declare const toUnsignedBlockBoundWitness: {
         $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
     } | undefined;
     (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
         schema: "network.xyo.boundwitness" & {
@@ -163,6 +168,7 @@ export declare const toUnsignedBlockBoundWitness: {
         $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
     };
 };
 //# sourceMappingURL=UnsignedBlockBoundWitness.d.ts.map

package/dist/neutral/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UnsignedBlockBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAI5B,qEAAqE;AACrE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;iBAGxC,CAAA;AAED,sEAAsE;AACtE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF,8EAA8E;AAC9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;CAA6C,CAAA;AACrF,0EAA0E;AAC1E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4E,CAAA;AACpH,2HAA2H;AAC3H,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4E,CAAA"}
+{"version":3,"file":"UnsignedBlockBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAI5B,qEAAqE;AACrE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGxC,CAAA;AAED,sEAAsE;AACtE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF,8EAA8E;AAC9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;CAA6C,CAAA;AACrF,0EAA0E;AAC1E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4E,CAAA;AACpH,2HAA2H;AAC3H,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4E,CAAA"}

package/dist/neutral/modules/protocol-model/evidence/EvidenceDisposition.d.ts

@@ -10,5 +10,5 @@ export declare const EvidenceDispositions: readonly ["expired", "finalized", "fo
 /** Reason a candidate block was archived as evidence. */
 export type EvidenceDisposition = typeof EvidenceDispositions[number];
 /** Zod schema for an evidence disposition. */
-export declare const EvidenceDispositionZod: z.ZodMiniLiteral<"expired" | "finalized" | "foreign" | "invalid" | "losing" | "malformed" | "superseded">;
+export declare const EvidenceDispositionZod: z.ZodMiniLiteral<"invalid" | "expired" | "finalized" | "foreign" | "losing" | "malformed" | "superseded">;
 //# sourceMappingURL=EvidenceDisposition.d.ts.map

package/dist/neutral/modules/protocol-model/evidence/EvidenceNotePayload.d.ts

@@ -16,7 +16,7 @@ export type EvidenceNoteSchema = typeof EvidenceNoteSchema;
  */
 export declare const EvidenceNoteFieldsZod: z.ZodMiniObject<{
     bundle: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-    disposition: z.ZodMiniLiteral<"expired" | "finalized" | "foreign" | "invalid" | "losing" | "malformed" | "superseded">;
+    disposition: z.ZodMiniLiteral<"invalid" | "expired" | "finalized" | "foreign" | "losing" | "malformed" | "superseded">;
     height: z.ZodMiniOptional<import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>>;
     observed: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
     producer: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {

package/dist/neutral/modules/protocol-model/model/AccountBalance.d.ts

@@ -12,6 +12,7 @@ export declare const AccountBalanceHistoryItemZod: z.ZodMiniTuple<readonly [z.Zo
     previous: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
     protocol: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
     step_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+    supersedes: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
     schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
         readonly __schema: true;
     }>;

package/dist/neutral/modules/protocol-model/model/AccountBalance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccountBalance.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/AccountBalance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAG5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAGpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAG7D,qEAAqE;AACrE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAIvC,CAAA;AAEF,sEAAsE;AACtE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF,+DAA+D;AAC/D,eAAO,MAAM,uBAAuB;;;;+DAA0B,CAAA;AAC9D,gEAAgE;AAChE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC1E,yEAAyE;AACzE,eAAO,MAAM,sBAAsB;;;;EAAwC,CAAA;AAE3E,oGAAoG;AACpG,MAAM,WAAW,2BAA2B;IAC1C,wGAAwG;IACxG,gCAAgC,CAC9B,OAAO,EAAE,UAAU,EAAE,EACrB,MAAM,EAAE,oBAAoB,GAC3B,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,UAAU,EAAE,yBAAyB,EAAE,CAAC,CAAC,CAAC,CAAA;IAE9E,8FAA8F;IAC9F,wBAAwB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,oBAAoB,GAAG,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CACvI;AAED,wDAAwD;AACxD,MAAM,WAAW,oBAAqB,SAAQ,2BAA2B,EAAE,QAAQ,CAAC,2BAA2B,CAAC;IAC9G,2DAA2D;IAC3D,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IAEvF,kEAAkE;IAClE,uBAAuB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,yBAAyB,EAAE,CAAC,CAAC,CAAA;IAE1I,oDAAoD;IACpD,qBAAqB,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC,yBAAyB,EAAE,CAAC,CAAA;IAElH,wEAAwE;IACxE,eAAe,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/G;AAED,gEAAgE;AAChE,eAAO,MAAM,2BAA2B,EAAG,sBAA+B,CAAA;AAC1E,kEAAkE;AAClE,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA"}
+{"version":3,"file":"AccountBalance.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/AccountBalance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAG5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAGpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAG7D,qEAAqE;AACrE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAIvC,CAAA;AAEF,sEAAsE;AACtE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF,+DAA+D;AAC/D,eAAO,MAAM,uBAAuB;;;;+DAA0B,CAAA;AAC9D,gEAAgE;AAChE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC1E,yEAAyE;AACzE,eAAO,MAAM,sBAAsB;;;;EAAwC,CAAA;AAE3E,oGAAoG;AACpG,MAAM,WAAW,2BAA2B;IAC1C,wGAAwG;IACxG,gCAAgC,CAC9B,OAAO,EAAE,UAAU,EAAE,EACrB,MAAM,EAAE,oBAAoB,GAC3B,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,UAAU,EAAE,yBAAyB,EAAE,CAAC,CAAC,CAAC,CAAA;IAE9E,8FAA8F;IAC9F,wBAAwB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,oBAAoB,GAAG,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CACvI;AAED,wDAAwD;AACxD,MAAM,WAAW,oBAAqB,SAAQ,2BAA2B,EAAE,QAAQ,CAAC,2BAA2B,CAAC;IAC9G,2DAA2D;IAC3D,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IAEvF,kEAAkE;IAClE,uBAAuB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,yBAAyB,EAAE,CAAC,CAAC,CAAA;IAE1I,oDAAoD;IACpD,qBAAqB,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC,yBAAyB,EAAE,CAAC,CAAA;IAElH,wEAAwE;IACxE,eAAe,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAA;CAC/G;AAED,gEAAgE;AAChE,eAAO,MAAM,2BAA2B,EAAG,sBAA+B,CAAA;AAC1E,kEAAkE;AAClE,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/ChainContext.zod.d.ts

@@ -14,6 +14,7 @@ export declare const ChainContextReadZod: import("zod").ZodObject<{
         previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
         step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;
@@ -52,6 +53,7 @@ export declare const ChainContextWriteZod: import("zod").ZodObject<{
         previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
         step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;
@@ -90,6 +92,7 @@ export declare const ChainContextZod: import("zod").ZodObject<{
         previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
         step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;

package/dist/neutral/modules/protocol-model/model/Context/ChainContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChainContext.zod.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/ChainContext.zod.ts"],"names":[],"mappings":"AAKA,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAA2D,CAAA;AAE3F,4DAA4D;AAC5D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEhC,CAAA;AAED,sDAAsD;AACtD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAE3B,CAAA"}
+{"version":3,"file":"ChainContext.zod.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/ChainContext.zod.ts"],"names":[],"mappings":"AAKA,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAA2D,CAAA;AAE3F,4DAA4D;AAC5D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEhC,CAAA;AAED,sDAAsD;AACtD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAE3B,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/HeadContext.zod.d.ts

@@ -8,6 +8,7 @@ export declare const HeadContextBaseZod: z.ZodObject<{
         previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
         step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;
@@ -45,6 +46,7 @@ export declare const HeadContextZod: z.ZodObject<{
         previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
         step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;

package/dist/neutral/modules/protocol-model/model/Context/HeadContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeadContext.zod.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/HeadContext.zod.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAKnB,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAE9B,CAAA;AAED,qDAAqD;AACrD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAyD,CAAA"}
+{"version":3,"file":"HeadContext.zod.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/HeadContext.zod.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAKnB,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAE9B,CAAA;AAED,qDAAqD;AACrD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAyD,CAAA"}

package/dist/neutral/modules/protocol-model/model/OffenseCode.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod/mini';
+/**
+ * Offense codes, in catalog order.
+ *
+ * A class keeps its code forever: a report names the code it was filed under, and that name has
+ * to still mean the same thing whenever the report is read back.
+ */
+export declare const OffenseCodes: readonly ["equivocation", "invalid-block", "reward-overmint", "false-anchor", "ineligible-production", "invalid-slash-request", "false-attestation"];
+/** An offense class. */
+export type OffenseCode = typeof OffenseCodes[number];
+/** Zod schema for an offense code. */
+export declare const OffenseCodeZod: z.ZodMiniLiteral<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation">;
+//# sourceMappingURL=OffenseCode.d.ts.map

package/dist/neutral/modules/protocol-model/model/OffenseCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OffenseCode.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/OffenseCode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,YAAY,sJAQf,CAAA;AAEV,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC,MAAM,CAAC,CAAA;AAErD,sCAAsC;AACtC,eAAO,MAAM,cAAc,mKAA0B,CAAA"}

package/dist/neutral/modules/protocol-model/model/RuleActivation.d.ts

@@ -0,0 +1,63 @@
+import type { OffenseCode } from './OffenseCode.js';
+/**
+ * Rules whose activation is recorded in the register.
+ *
+ * Offense classes carry two heights rather than one. A class becomes *reportable* before it
+ * becomes *adjudicable*, so reports can be recorded and measured for a while before anything
+ * they say has consequences — which is the only way to learn what reporting looks like without
+ * risking a wrong punishment.
+ *
+ * This list lives beside the offense codes rather than with the register, because in-block
+ * validators have to name rules without depending on the register document's shape.
+ */
+export declare const RuleIds: readonly ["intent-binding", "anchor-rules", "single-signer", "supersedes-field", "slash-payloads", "eligibility-admission", "attestation-admission", "certificate-execution", ...("equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable")[]];
+/** A rule whose activation height the register records. */
+export type RuleId = typeof RuleIds[number];
+/** The rule id gating whether reports naming an offense may be recorded. */
+export declare function reportableRuleId(offense: OffenseCode): RuleId;
+/** The rule id gating whether reports naming an offense may be acted upon. */
+export declare function adjudicableRuleId(offense: OffenseCode): RuleId;
+/**
+ * Where a rule stands at a height.
+ *
+ * `grace` is the interval just after activation where a rule is observed but not enforced. It
+ * exists because nodes upgrade at different moments: without it, a rule turning on would punish
+ * operators whose only mistake was being mid-rollout.
+ */
+export type RuleActivationState = 'inactive' | 'grace' | 'active';
+/**
+ * The minimum a caller must supply to resolve rule activation.
+ *
+ * Deliberately narrower than the register document: an in-block validator needs to know when
+ * rules turn on, not what the chain charges for a deposit. A full register version satisfies this
+ * structurally, so nothing has to convert between them.
+ */
+export interface RuleActivationParams {
+    /** Rule id to the height it takes effect. */
+    activations: Partial<Record<RuleId, number>>;
+    /** Rule id to the height it stops taking effect. */
+    deactivations?: Partial<Record<RuleId, number>>;
+    /** Blocks after an activation during which the rule is observed but not enforced. */
+    graceBandXl1Blocks?: number;
+}
+/**
+ * Where a rule stands at an XL1 height, according to a set of activations.
+ *
+ * A rule with no recorded activation is inactive — saying nothing about a rule is how a network
+ * declines it, which is what lets one register describe a network running exactly as it always
+ * has. A params view carrying no grace band grants no grace.
+ * @param params The activation heights in force
+ * @param ruleId The rule to resolve
+ * @param height The XL1 height being judged
+ * @returns Whether the rule is inactive, in its grace band, or enforced
+ */
+export declare function ruleActivationStateAt(params: RuleActivationParams, ruleId: RuleId, height: number): RuleActivationState;
+/** Whether a rule is enforced at a height. */
+export declare function isRuleActiveAt(params: RuleActivationParams, ruleId: RuleId, height: number): boolean;
+/**
+ * Whether a rule is at least being observed at a height — enforced, or inside its grace band.
+ *
+ * This is the gate for recording and measuring. Enforcement asks the stricter question.
+ */
+export declare function isRuleObservedAt(params: RuleActivationParams, ruleId: RuleId, height: number): boolean;
+//# sourceMappingURL=RuleActivation.d.ts.map

package/dist/neutral/modules/protocol-model/model/RuleActivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleActivation.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/RuleActivation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,0nBAWV,CAAA;AAEV,2DAA2D;AAC3D,MAAM,MAAM,MAAM,GAAG,OAAO,OAAO,CAAC,MAAM,CAAC,CAAA;AAE3C,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE7D;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE9D;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,oDAAoD;IACpD,aAAa,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC/C,qFAAqF;IACrF,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,mBAAmB,CAMrB;AAED,8CAA8C;AAC9C,wBAAgB,cAAc,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpG;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtG"}

package/dist/neutral/modules/protocol-model/model/SyncStepSummary.d.ts

@@ -224,6 +224,7 @@ export declare const SyncStepSummaryZod: z.ZodArray<import("zod/mini").ZodMiniTu
     previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
     protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
     step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+    supersedes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
     $epoch: import("zod/mini").ZodMiniNumber<number>;
     _hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
     _dataHash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
@@ -262,6 +263,7 @@ export declare const isSyncStepSummary: <T>(value: T) => value is T & [{
     $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
     protocol?: number | undefined;
     step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
 }, {
     [x: string]: unknown;
     schema: import("@xyo-network/sdk").BrandedSchema<string>;
@@ -297,6 +299,7 @@ export declare const asSyncStepSummary: {
         $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
     }, {
         [x: string]: unknown;
         schema: import("@xyo-network/sdk").BrandedSchema<string>;
@@ -330,6 +333,7 @@ export declare const asSyncStepSummary: {
         $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
     }, {
         [x: string]: unknown;
         schema: import("@xyo-network/sdk").BrandedSchema<string>;
@@ -366,6 +370,7 @@ export declare const toSyncStepSummary: {
         $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
     }, {
         [x: string]: unknown;
         schema: import("@xyo-network/sdk").BrandedSchema<string>;
@@ -399,6 +404,7 @@ export declare const toSyncStepSummary: {
         $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
     }, {
         [x: string]: unknown;
         schema: import("@xyo-network/sdk").BrandedSchema<string>;

package/dist/neutral/modules/protocol-model/model/SyncStepSummary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SyncStepSummary.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/SyncStepSummary.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,mEAAmE;AACnE,eAAO,MAAM,0BAA0B;;;;;;;;;;;iBAWrC,CAAA;AAEF,oEAAoE;AACpE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,0EAA0E;AAC1E,eAAO,MAAM,yBAAyB;;;;;;;;;;;CAA2C,CAAA;AACjF,wEAAwE;AACxE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;CAAwE,CAAA;AAC9G,yHAAyH;AACzH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;CAAwE,CAAA;AAE9G,iEAAiE;AACjE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;iBAMnC,CAAA;AAEF,kEAAkE;AAClE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,wEAAwE;AACxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;CAAyC,CAAA;AAC7E,sEAAsE;AACtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AACxG,uHAAuH;AACvH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AAExG,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAA8C,CAAA;AAE7E,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,oEAAoE;AACpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAmC,CAAA;AACjE,gEAAgE;AAChE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA;AACtF,gHAAgH;AAChH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA"}
+{"version":3,"file":"SyncStepSummary.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/SyncStepSummary.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,mEAAmE;AACnE,eAAO,MAAM,0BAA0B;;;;;;;;;;;iBAWrC,CAAA;AAEF,oEAAoE;AACpE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,0EAA0E;AAC1E,eAAO,MAAM,yBAAyB;;;;;;;;;;;CAA2C,CAAA;AACjF,wEAAwE;AACxE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;CAAwE,CAAA;AAC9G,yHAAyH;AACzH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;CAAwE,CAAA;AAE9G,iEAAiE;AACjE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;iBAMnC,CAAA;AAEF,kEAAkE;AAClE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,wEAAwE;AACxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;CAAyC,CAAA;AAC7E,sEAAsE;AACtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AACxG,uHAAuH;AACvH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AAExG,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAA8C,CAAA;AAE7E,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,oEAAoE;AACpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAmC,CAAA;AACjE,gEAAgE;AAChE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA;AACtF,gHAAgH;AAChH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA"}

package/dist/neutral/modules/protocol-model/model/index.d.ts

@@ -10,6 +10,7 @@ export * from './defaultTransactionFees.js';
 export * from './GatewayName.js';
 export * from './HydratedTransaction.js';
 export * from './minTransactionFees.js';
+export * from './OffenseCode.js';
 export * from './OpCodes.js';
 export * from './PayloadMap.js';
 export * from './Permission.js';
@@ -19,6 +20,7 @@ export * from './RangeMultipliers.js';
 export * from './rewards.js';
 export * from './RewardShare.js';
 export * from './RewardsRangeOptions.js';
+export * from './RuleActivation.js';
 export * from './Sequence.js';
 export * from './Stake.js';
 export * from './SyncStepSummary.js';

package/dist/neutral/modules/protocol-model/model/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,yBAAyB,CAAA;AACvC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,yBAAyB,CAAA;AACvC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,qBAAqB,CAAA;AACnC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA"}

package/dist/neutral/modules/protocol-model/model/version.d.ts

@@ -1,11 +1,11 @@
 /** Protocol constant defining xl1 protocol version major. */
 export declare const XL1_PROTOCOL_VERSION_MAJOR: 1;
 /** Protocol constant defining xl1 protocol version minor. */
-export declare const XL1_PROTOCOL_VERSION_MINOR: 2;
+export declare const XL1_PROTOCOL_VERSION_MINOR: 3;
 /** Protocol constant defining xl1 protocol version patch. */
 export declare const XL1_PROTOCOL_VERSION_PATCH: 0;
 /** Protocol constant defining xl1 protocol version string. */
-export declare const XL1_PROTOCOL_VERSION_STRING: "1.2.0";
+export declare const XL1_PROTOCOL_VERSION_STRING: "1.3.0";
 /** Protocol constant defining xl1 protocol version. */
 export declare const XL1_PROTOCOL_VERSION: number;
 //# sourceMappingURL=version.d.ts.map

package/dist/neutral/modules/protocol-model/payload/index.d.ts

@@ -1,5 +1,6 @@
 export * from './application/index.js';
 export * from './elevatable/index.js';
+export * from './slash/index.js';
 export * from './StepIdentityPayload.js';
 export * from './StepWitness.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-model/payload/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,kBAAkB,CAAA"}

package/dist/neutral/modules/protocol-model/payload/slash/SlashAdjudicationPayload.d.ts

@@ -0,0 +1,51 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Possible outcomes of adjudicating a slash request. */
+export declare const SlashOutcomes: readonly ["confirmed", "refuted", "indeterminate", "invalid"];
+/** The outcome of adjudicating a slash request. */
+export type SlashOutcome = typeof SlashOutcomes[number];
+/** Zod schema for a slash outcome. */
+export declare const SlashOutcomeZod: z.ZodMiniLiteral<"confirmed" | "refuted" | "indeterminate" | "invalid">;
+/** Schema identifier for slash adjudication payloads. */
+export declare const SlashAdjudicationSchema: "network.xyo.chain.slash.adjudication" & {
+    readonly __schema: true;
+};
+/** Schema type for slash adjudication payloads. */
+export type SlashAdjudicationSchema = typeof SlashAdjudicationSchema;
+/**
+ * Fields for the record that closes a slash request.
+ *
+ * Four outcomes, and the distinctions between them are the whole design. `confirmed` proceeds to
+ * a slash. `refuted` means counter-evidence held — the reporter was not wrong to ask.
+ * `indeterminate` means the check could not be completed from what was available, and costs
+ * nobody anything. Only `invalid` means the report was provably wrong, and only that opens a
+ * counter-slash against its filer.
+ *
+ * Collapsing the middle two into "failed" is what would make honest reporting dangerous: a
+ * reporter who hit a data-availability gap would be punished the same as one who fabricated.
+ */
+export declare const SlashAdjudicationFieldsZod: z.ZodMiniObject<{
+    claimant: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+    claimantCommit: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    outcome: z.ZodMiniLiteral<"confirmed" | "refuted" | "indeterminate" | "invalid">;
+    reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    request: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+/** Fields represented by the slash adjudication contract. */
+export type SlashAdjudicationFields = z.infer<typeof SlashAdjudicationFieldsZod>;
+/** A slash adjudication payload — the on-chain record closing a report. */
+export type SlashAdjudication = Payload<SlashAdjudicationFields, SlashAdjudicationSchema>;
+/** Type guard that checks if a value is a valid SlashAdjudication. */
+export declare const isSlashAdjudication: (x?: unknown) => x is SlashAdjudication;
+/** Casts a value to SlashAdjudication or returns undefined if invalid. */
+export declare const asSlashAdjudication: import("@ariestools/sdk").AsTypeFunction<SlashAdjudication>;
+//# sourceMappingURL=SlashAdjudicationPayload.d.ts.map

package/dist/neutral/modules/protocol-model/payload/slash/SlashAdjudicationPayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlashAdjudicationPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashAdjudicationPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,yDAAyD;AACzD,eAAO,MAAM,aAAa,+DAAgE,CAAA;AAE1F,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,MAAM,CAAC,CAAA;AAEvD,sCAAsC;AACtC,eAAO,MAAM,eAAe,yEAA2B,CAAA;AAEvD,yDAAyD;AACzD,eAAO,MAAM,uBAAuB;;CAAyD,CAAA;AAC7F,mDAAmD;AACnD,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAA;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;iBAarC,CAAA;AAEF,6DAA6D;AAC7D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,2EAA2E;AAC3E,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,uBAAuB,EAAE,uBAAuB,CAAC,CAAA;AAEzF,sEAAsE;AACtE,eAAO,MAAM,mBAAmB,yCAG/B,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,6DAA8C,CAAA"}

package/dist/neutral/modules/protocol-model/payload/slash/SlashChallengePayload.d.ts

@@ -0,0 +1,33 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Schema identifier for slash challenge payloads. */
+export declare const SlashChallengeSchema: "network.xyo.chain.slash.challenge" & {
+    readonly __schema: true;
+};
+/** Schema type for slash challenge payloads. */
+export type SlashChallengeSchema = typeof SlashChallengeSchema;
+/**
+ * Fields for a challenge to a slash request.
+ *
+ * Anyone may challenge and no bond is required, because a challenge can only exculpate. A
+ * frivolous one fails to change the verdict and costs its filer the fee; there is no version of
+ * it that harms the accused, so there is nothing to deter.
+ */
+export declare const SlashChallengeFieldsZod: z.ZodMiniObject<{
+    evidence: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    request: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+/** Fields represented by the slash challenge contract. */
+export type SlashChallengeFields = z.infer<typeof SlashChallengeFieldsZod>;
+/** A slash challenge payload — counter-evidence against a pending report. */
+export type SlashChallenge = Payload<SlashChallengeFields, SlashChallengeSchema>;
+/** Type guard that checks if a value is a valid SlashChallenge. */
+export declare const isSlashChallenge: (x?: unknown) => x is SlashChallenge;
+/** Casts a value to SlashChallenge or returns undefined if invalid. */
+export declare const asSlashChallenge: import("@ariestools/sdk").AsTypeFunction<SlashChallenge>;
+//# sourceMappingURL=SlashChallengePayload.d.ts.map

package/dist/neutral/modules/protocol-model/payload/slash/SlashChallengePayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlashChallengePayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashChallengePayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAsD,CAAA;AACvF,gDAAgD;AAChD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBAOlC,CAAA;AAEF,0DAA0D;AAC1D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,oBAAoB,EAAE,oBAAoB,CAAC,CAAA;AAEhF,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,sCAAoF,CAAA;AAEjH,uEAAuE;AACvE,eAAO,MAAM,gBAAgB,0DAA2C,CAAA"}

package/dist/neutral/modules/protocol-model/payload/slash/SlashCommitPayload.d.ts

@@ -0,0 +1,35 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Schema identifier for slash commit payloads. */
+export declare const SlashCommitSchema: "network.xyo.chain.slash.commit" & {
+    readonly __schema: true;
+};
+/** Schema type for slash commit payloads. */
+export type SlashCommitSchema = typeof SlashCommitSchema;
+/**
+ * Fields for a slash commitment.
+ *
+ * A report's evidence becomes public the moment it is recorded, and whoever orders the next block
+ * decides which copy of it lands first. Committing to the report before revealing it is what
+ * stops a reporter's work from being lifted and re-filed under someone else's name.
+ *
+ * The commitment is the hash of the whole report, so it binds the reporter, the accused, the
+ * offense, and the evidence together — none of them can be swapped after the fact.
+ */
+export declare const SlashCommitFieldsZod: z.ZodMiniObject<{
+    commitment: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+}, z.core.$strip>;
+/** Fields represented by the slash commit contract. */
+export type SlashCommitFields = z.infer<typeof SlashCommitFieldsZod>;
+/** A slash commit payload — reserves a report before its evidence is public. */
+export type SlashCommit = Payload<SlashCommitFields, SlashCommitSchema>;
+/** Type guard that checks if a value is a valid SlashCommit. */
+export declare const isSlashCommit: (x?: unknown) => x is SlashCommit;
+/** Casts a value to SlashCommit or returns undefined if invalid. */
+export declare const asSlashCommit: import("@ariestools/sdk").AsTypeFunction<SlashCommit>;
+//# sourceMappingURL=SlashCommitPayload.d.ts.map

package/dist/neutral/modules/protocol-model/payload/slash/SlashCommitPayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlashCommitPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashCommitPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,mDAAmD;AACnD,eAAO,MAAM,iBAAiB;;CAAmD,CAAA;AACjF,6CAA6C;AAC7C,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;;;;;iBAK/B,CAAA;AAEF,uDAAuD;AACvD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAA;AAEvE,gEAAgE;AAChE,eAAO,MAAM,aAAa,mCAA2E,CAAA;AAErG,oEAAoE;AACpE,eAAO,MAAM,aAAa,uDAAwC,CAAA"}

package/dist/neutral/modules/protocol-model/payload/slash/SlashEvidencePayload.d.ts

@@ -0,0 +1,33 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Schema identifier for slash evidence payloads. */
+export declare const SlashEvidenceSchema: "network.xyo.chain.slash.evidence" & {
+    readonly __schema: true;
+};
+/** Schema type for slash evidence payloads. */
+export type SlashEvidenceSchema = typeof SlashEvidenceSchema;
+/**
+ * Fields for a slash evidence container.
+ *
+ * Evidence is signed bound witnesses — blocks, transactions, attestations. Those cannot ride
+ * on-chain as bare payloads, because a bound witness in a block's payload set would be read as
+ * one of that block's transactions. Carrying them inside an opaque container keeps them verbatim,
+ * which matters: the whole point of the evidence is that its signatures still verify.
+ */
+export declare const SlashEvidenceFieldsZod: z.ZodMiniObject<{
+    artifacts: z.ZodMiniArray<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
+    from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+}, z.core.$strip>;
+/** Fields represented by the slash evidence contract. */
+export type SlashEvidenceFields = z.infer<typeof SlashEvidenceFieldsZod>;
+/** A slash evidence payload — signed artifacts carried on-chain without being interpreted. */
+export type SlashEvidence = Payload<SlashEvidenceFields, SlashEvidenceSchema>;
+/** Type guard that checks if a value is a valid SlashEvidence. */
+export declare const isSlashEvidence: (x?: unknown) => x is SlashEvidence;
+/** Casts a value to SlashEvidence or returns undefined if invalid. */
+export declare const asSlashEvidence: import("@ariestools/sdk").AsTypeFunction<SlashEvidence>;
+//# sourceMappingURL=SlashEvidencePayload.d.ts.map

package/dist/neutral/modules/protocol-model/payload/slash/SlashEvidencePayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlashEvidencePayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashEvidencePayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,qDAAqD;AACrD,eAAO,MAAM,mBAAmB;;CAAqD,CAAA;AACrF,+CAA+C;AAC/C,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA;AAE5D;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;;iBAKjC,CAAA;AAEF,yDAAyD;AACzD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE,8FAA8F;AAC9F,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,mBAAmB,EAAE,mBAAmB,CAAC,CAAA;AAE7E,kEAAkE;AAClE,eAAO,MAAM,eAAe,qCAAiF,CAAA;AAE7G,sEAAsE;AACtE,eAAO,MAAM,eAAe,yDAA0C,CAAA"}

package/dist/neutral/modules/protocol-model/payload/slash/SlashRequestPayload.d.ts

@@ -0,0 +1,46 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Schema identifier for slash request payloads. */
+export declare const SlashRequestSchema: "network.xyo.chain.slash.request" & {
+    readonly __schema: true;
+};
+/** Schema type for slash request payloads. */
+export type SlashRequestSchema = typeof SlashRequestSchema;
+/**
+ * Fields for a slash request — an accusation that a specific address committed a specific offense.
+ *
+ * A request carries no argument, only artifacts and a catalog entry. If an offense cannot be
+ * expressed that way it is not reportable, which is what keeps accusation mechanical: the same
+ * request produces the same verdict for anyone who checks it, and there is nothing to be
+ * persuaded by.
+ *
+ * Every offense locates at exactly one height, so there is no range to disagree about when
+ * deciding whether two reports are the same accusation.
+ */
+export declare const SlashRequestFieldsZod: z.ZodMiniObject<{
+    accused: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+    catalog: z.ZodMiniNumber<number>;
+    chain: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    evidence: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    evm: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    offense: z.ZodMiniLiteral<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation">;
+}, z.core.$strip>;
+/** Fields represented by the slash request contract. */
+export type SlashRequestFields = z.infer<typeof SlashRequestFieldsZod>;
+/** A slash request payload — an evidence-bearing accusation. */
+export type SlashRequest = Payload<SlashRequestFields, SlashRequestSchema>;
+/** Type guard that checks if a value is a valid SlashRequest. */
+export declare const isSlashRequest: (x?: unknown) => x is SlashRequest;
+/** Casts a value to SlashRequest or returns undefined if invalid. */
+export declare const asSlashRequest: import("@ariestools/sdk").AsTypeFunction<SlashRequest>;
+//# sourceMappingURL=SlashRequestPayload.d.ts.map

package/dist/neutral/modules/protocol-model/payload/slash/SlashRequestPayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlashRequestPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashRequestPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAM5B,oDAAoD;AACpD,eAAO,MAAM,kBAAkB;;CAAoD,CAAA;AACnF,8CAA8C;AAC9C,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA;AAE1D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAiBhC,CAAA;AAEF,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE,gEAAgE;AAChE,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAAA;AAE1E,iEAAiE;AACjE,eAAO,MAAM,cAAc,oCAA8E,CAAA;AAEzG,qEAAqE;AACrE,eAAO,MAAM,cAAc,wDAAyC,CAAA"}

package/dist/neutral/modules/protocol-model/payload/slash/index.d.ts

@@ -0,0 +1,6 @@
+export * from './SlashAdjudicationPayload.js';
+export * from './SlashChallengePayload.js';
+export * from './SlashCommitPayload.js';
+export * from './SlashEvidencePayload.js';
+export * from './SlashRequestPayload.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-model/payload/slash/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,2BAA2B,CAAA;AACzC,cAAc,0BAA0B,CAAA"}